home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / net / sun4.md / netUltra.c < prev   
Encoding:
C/C++ Source or Header  |  1992-12-19  |  86.6 KB  |  3,040 lines
  1. /* 
  2.  * netUltra.c --
  3.  *
  4.  *    Routines for handling the Ultranet VME Adapter card..
  5.  *
  6.  * Copyright 1990 Regents of the University of California
  7.  * Permission to use, copy, modify, and distribute this
  8.  * software and its documentation for any purpose and without
  9.  * fee is hereby granted, provided that the above copyright
  10.  * notice appear in all copies.  The University of California
  11.  * makes no representations about the suitability of this
  12.  * software for any purpose.  It is provided "as is" without
  13.  * express or implied warranty.
  14.  */
  15.  
  16. #ifndef lint
  17. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/net/sun4.md/netUltra.c,v 1.7 92/04/14 22:34:08 jhh Exp $ SPRITE (Berkeley)";
  18. #endif /* not lint */
  19.  
  20. #include <sprite.h>
  21. #include <vm.h>
  22. #include <vmMach.h>
  23. #include <mach.h>
  24. #include <netUltraInt.h>
  25. #include <dev/ultra.h>
  26. #include <fmt.h>
  27. #include <sync.h>
  28. #include <dbg.h>
  29. #include <rpcPacket.h>
  30. #include <assert.h>
  31.  
  32. /*
  33.  * "Borrow" the Vax format for the format of the Ultranet adapter (it
  34.  * is really a 386.  We need to swap some of the words in the
  35.  * diagnostic and information structures.
  36.  */
  37.  
  38. #define NET_ULTRA_FORMAT FMT_VAX_FORMAT
  39.  
  40. Boolean        netUltraDebug = FALSE;
  41. Boolean        netUltraTrace = TRUE;
  42. int        netUltraMapThreshold = NET_ULTRA_MAP_THRESHOLD;
  43. static int    packetsSunk = 0;
  44. static Time    sinkStartTime;
  45. static Time    sinkEndTime;
  46.  
  47. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  48.  
  49. #define WAIT_FOR_REPLY(ptr, count) {        \
  50.     int    i;                    \
  51.     for(i = (count); i > 0; i -= 100) {        \
  52.     MACH_DELAY(100);            \
  53.     if (*((volatile int *)ptr) != 0) {    \
  54.         break;                \
  55.     }                    \
  56.     }                        \
  57. }
  58.  
  59. /*
  60.  * The following are the names of the diagnostic tests as listed in the
  61.  * uvm man page provided in the Ultranet documentation.
  62.  */
  63. static char    *diagNames[] = {
  64.     "EPROM checksum",
  65.     "Abbreviated RAM check",
  66.     "Interrupt controller and interval timer",
  67.     "Internal loopback",
  68.     "FIFO RAM check",
  69.     "Checksum gate arrays",
  70.     "NMI control logic"
  71. };
  72. /*
  73.  * The following are the names of the extended diagnostic tests as
  74.  * listed in the uvm man page.
  75.  */
  76. static char    *extDiagNames[] = {
  77.     "EPROM checksum",
  78.     "Full RAM check",
  79.     "Interrupt controller and interval timer",
  80.     "Internal or external loopback",
  81.     "FIFO RAM check",
  82.     "Checksum gate arrays",
  83.     "NMI control logic",
  84.     "DMA to hosts memory using VME bus",
  85.     "Extended FIFO RAM check",
  86.     "FIFO Control logic"
  87. };
  88.  
  89. /*
  90.  * This is a "wildcard" address that matches any TL address.
  91.  * Once again we have to lie about the size of a Net_Address
  92.  * since the adapter will puke if it isn't 7 bytes (why have it
  93.  * if you can't change it?).
  94.  */
  95. static Net_UltraTLAddress    wildcardAddress = 
  96.                 {7, NET_ULTRA_TSAP_SIZE};
  97.  
  98. /*
  99.  * Forward declarations.
  100.  */
  101.  
  102. static Sync_Condition    dsndTestDone;
  103. static int        dsndCount;
  104.  
  105. static char         *GetStatusString _ARGS_ ((int status));
  106. static void        InitQueues _ARGS_((NetUltraState *statePtr));
  107. static void        StandardDone _ARGS_((Net_Interface *interPtr, 
  108.                 NetUltraXRBInfo *infoPtr));
  109. static void        ReadDone _ARGS_((Net_Interface *interPtr, 
  110.                 NetUltraXRBInfo *infoPtr));
  111. static void        EchoDone _ARGS_((Net_Interface *interPtr, 
  112.                 NetUltraXRBInfo *infoPtr));
  113. static ReturnStatus    NetUltraSendDgram _ARGS_((Net_Interface *interPtr,
  114.                 Net_Address *netAddressPtr, int count,
  115.                 int bufSize, Address buffer, Time *timePtr));
  116. static void        DgramSendDone _ARGS_((Net_Interface *interPtr, 
  117.                 NetUltraXRBInfo *infoPtr));
  118. static void        OutputDone _ARGS_((Net_Interface *interPtr, 
  119.                 NetUltraXRBInfo *infoPtr));
  120. static void        SourceDone _ARGS_((Net_Interface *interPtr, 
  121.                 NetUltraXRBInfo *infoPtr));
  122. static ReturnStatus    NetUltraSource _ARGS_((Net_Interface *interPtr,
  123.                 Net_Address *netAddressPtr, int count,
  124.                 int bufSize, Address buffer, Time *timePtr));
  125. static void        NetUltraResetCallback _ARGS_((ClientData data,
  126.                 Proc_CallInfo *infoPtr));
  127.  
  128. /*
  129.  * Macros for mapping between kernel, DVMA and VME addresses.
  130.  */
  131.  
  132. #define    DVMA_TO_BUFFER(addr, statePtr)         \
  133.     ((Address) (((((unsigned int) (addr)) -     \
  134.     ((unsigned int) (statePtr)->buffersDVMA)) + \
  135.     ((int) (statePtr)->buffers))))
  136.  
  137. #define BUFFER_TO_DVMA(addr, statePtr)         \
  138.     ((Address) ((((unsigned int) (addr)) -     \
  139.     ((unsigned int) (statePtr)->buffers)) +     \
  140.     ((unsigned int) (statePtr)->buffersDVMA)))
  141.  
  142. #define DVMA_TO_VME(addr, statePtr)         \
  143.     ((Address) (((unsigned int) (addr)) -     \
  144.     ((unsigned int) VMMACH_DMA_START_ADDR)))
  145.  
  146. #define VME_TO_DVMA(addr, statePtr)         \
  147.     ((Address) (((unsigned int) (addr)) +     \
  148.     ((unsigned int) VMMACH_DMA_START_ADDR)))
  149.  
  150. #define BUFFER_TO_VME(addr, statePtr) \
  151.     ((Address) (DVMA_TO_VME(BUFFER_TO_DVMA(addr,statePtr), (statePtr))))
  152.  
  153. #define VME_TO_BUFFER(addr, statePtr) \
  154.     ((Address) (DVMA_TO_BUFFER(VME_TO_DVMA((addr),statePtr),(statePtr))))
  155.  
  156. #define DVMA_ADDRESS(addr, statePtr) \
  157.     ((unsigned int) (addr) < ((unsigned int)VMMACH_DMA_START_ADDR)? FALSE :TRUE)
  158.  
  159.  
  160.  
  161. /*
  162.  *----------------------------------------------------------------------
  163.  *
  164.  * NetUltraInit --
  165.  *
  166.  *    Initialize the Ultranet VME adapter card.
  167.  *
  168.  * Results:
  169.  *    SUCCESS if the Ultranet card was found and initialized.
  170.  *    FAILURE otherwise.
  171.  *
  172.  * Side effects:
  173.  *    None.
  174.  *
  175.  *----------------------------------------------------------------------
  176.  */
  177.  
  178. ReturnStatus
  179. NetUltraInit(interPtr)
  180.     Net_Interface    *interPtr;     /* Network interface. */
  181. {
  182.     unsigned int        ctrlAddr;
  183.     NetUltraState        *statePtr;
  184.     ReturnStatus        status = SUCCESS;
  185.     int                zero = 0;
  186.     NetUltraExtDiagCommand     extDiagCmd;
  187.     NetUltraInfoCommand        infoCmd;
  188.     char            *buffer;
  189.  
  190.     /*
  191.      * Make sure that we agree with the adapter as to the size of the 
  192.      * command blocks and other structures.
  193.      */
  194.     assert(sizeof(Net_UltraAddress) == 8);
  195.     assert(sizeof(Net_UltraTLAddress) == 16);
  196.     assert(sizeof(Net_UltraHeader) == 56);
  197.     assert(sizeof(NetUltraDMAInfo) == 16);
  198.     assert(sizeof(NetUltraRequestHdr) == 16);
  199.     assert(sizeof(NetUltraDatagramRequest) == 56);
  200.     assert(sizeof(NetUltraStartRequest) == 112);
  201.     assert(sizeof(NetUltraStopRequest) == 16);
  202.     assert(sizeof(NetUltraRequest) == 112);
  203.     assert(sizeof(NetUltraXRB) == 132);
  204.     assert(sizeof(NetUltraInitCommand) == 64);
  205.     assert(sizeof(NetUltraDiagCommand) == 36);
  206.     assert(sizeof(NetUltraExtDiagCommand) == 24);
  207.     assert(sizeof(NetUltraLoadCommand) == 24);
  208.     assert(sizeof(NetUltraGoCommand) == 12);
  209.     assert(sizeof(Net_UltraHeader) == sizeof(NetUltraDatagramRequest));
  210.  
  211.     ctrlAddr = (unsigned int) interPtr->ctrlAddr;
  212.     /*
  213.      * If the address is physical (not in kernel's virtual address space)
  214.      * then we have to map it in.
  215.      */
  216.     if (interPtr->virtual == FALSE) {
  217.     ctrlAddr = (unsigned int) VmMach_MapInDevice((Address) ctrlAddr, 3);
  218.     }
  219.     statePtr = (NetUltraState *) malloc (sizeof(NetUltraState));
  220.     bzero((char *) statePtr, sizeof(NetUltraState));
  221.     /*
  222.      * The first register is the interrupt register, then
  223.      * the reset register, separated by 12 bytes.
  224.      */
  225.     statePtr->intrReg = (int *) ctrlAddr;
  226.     statePtr->resetReg = (int *) (ctrlAddr + 0x10);
  227.     /*
  228.      * Now poke the reset register.
  229.      */
  230.     status = Mach_Probe(sizeof(int), (char *) &zero,
  231.         (char *) statePtr->resetReg);
  232.     if (status != SUCCESS) {
  233.     /* 
  234.      * Got a bus error.
  235.      */
  236.     goto exit;
  237.     }
  238.     if (netUltraDebug) {
  239.     printf("NetUltraInit: adapter at 0x%x probed successfully\n",
  240.         statePtr->intrReg);
  241.     }
  242.     MACH_DELAY(NET_ULTRA_RESET_DELAY);
  243.     statePtr->magic = NET_ULTRA_STATE_MAGIC;
  244.     statePtr->flags = NET_ULTRA_STATE_EXIST | NET_ULTRA_STATE_EPROM |
  245.             NET_ULTRA_STATE_NORMAL;
  246.     statePtr->interPtr = interPtr;
  247.     interPtr->interfaceData = (ClientData) statePtr;
  248.     statePtr->tracePtr = statePtr->traceBuffer;
  249.     statePtr->traceSequence = 0;
  250.     /*
  251.      * Get the adapter information.
  252.      */
  253.     status = NetUltraInfo(statePtr, &infoCmd);
  254.     if (status == SUCCESS) {
  255.     printf(
  256.     "UltraNet adapter %d.%d, Revision %d, Option %d, Firmware %d, Serial %d\n",
  257.         infoCmd.hwModel, infoCmd.hwVersion, 
  258.         infoCmd.hwRevision, infoCmd.hwOption,
  259.         infoCmd.version, infoCmd.hwSerial);
  260.     if (infoCmd.error == 0) {
  261.         printf("Ultranet adapter passed all diagnostics.\n");
  262.     } else {
  263.         int    tmp = infoCmd.error;
  264.         int i;
  265.         printf(
  266.         "Ultranet adapter failed diagnostics (0x%x).\n", tmp);
  267.         printf("The following tests failed:\n");
  268.         for (i = 0; i < sizeof(int) * 8; i++) {
  269.         if (tmp & 1) {
  270.             printf("%2d: %s\n", i+1, diagNames[i]);
  271.         }
  272.         tmp >>= 1;
  273.         }
  274.         status = FAILURE;
  275.         goto exit;
  276.     }
  277.     } else {
  278.     printf("NetUltraInit: unable to send info command to adapter\n");
  279.     goto exit;
  280.     }
  281.     /*
  282.      * Send an extended diagnostics command to the adapter.
  283.      */
  284.     buffer = (char *) malloc(NET_ULTRA_EXT_DIAG_BUF_SIZE);
  285.     status = NetUltraExtDiag(statePtr, FALSE, buffer, &extDiagCmd);
  286.     free(buffer);
  287.     if (status == SUCCESS) {
  288.     if (extDiagCmd.error == 0) {
  289.         printf("Ultranet adapter passed all extended diagnostics.\n");
  290.     } else {
  291.         int    tmp = extDiagCmd.error;
  292.         int i;
  293.         printf(
  294.         "Ultranet adapter failed extended diagnostics (0x%x).\n", tmp);
  295.         printf("The following tests failed:\n");
  296.         for (i = 0; i < sizeof(int) * 8; i++) {
  297.         if (tmp & 1) {
  298.             printf("%2d: %s\n", i+1, extDiagNames[i]);
  299.         }
  300.         tmp >>= 1;
  301.         }
  302.         status = FAILURE;
  303.         goto exit;
  304.     } 
  305.     } else {
  306.     printf(
  307.     "NetUltraInit: unable to send extended diagnostics command to adapter\n");
  308.     goto exit;
  309.     }
  310.     interPtr->ctrlAddr = (Address) ctrlAddr;
  311.     statePtr->queuesInit = FALSE;
  312.     InitQueues(statePtr);
  313.     statePtr->priority = NET_ULTRA_INTERRUPT_PRIORITY;
  314.     statePtr->requestLevel = NET_ULTRA_VME_REQUEST_LEVEL;
  315.     statePtr->addressSpace = NET_ULTRA_VME_ADDRESS_SPACE;
  316.     Mach_SetHandler(interPtr->vector, Net_Intr, (ClientData) interPtr);
  317.     interPtr->init     = NetUltraInit;
  318.     interPtr->intr    = NetUltraIntr;
  319.     interPtr->ioctl    = NetUltraIOControl;
  320.     interPtr->reset     = Net_UltraReset;
  321.     interPtr->output     = NetUltraOutput;
  322.     interPtr->netType    = NET_NETWORK_ULTRA;
  323.     interPtr->maxBytes    = NET_ULTRA_MAX_BYTES;
  324.     interPtr->minBytes    = NET_ULTRA_MIN_BYTES;
  325.     if (sizeof(NetUltraXRB) != 132) {
  326.     printf("NetUltraInit: WARNING: NetUltraXRB is not 132 bytes!!!\n");
  327.     }
  328. exit:
  329.     if (status != SUCCESS && statePtr != (NetUltraState *) NIL) {
  330.     free((char *) statePtr);
  331.     }
  332.     return status;
  333. }
  334.  
  335. /*
  336.  *----------------------------------------------------------------------
  337.  *
  338.  * NetUltraHardReset --
  339.  *
  340.  *    Does a hard reset of the Ultranet adapter. This means the adapter
  341.  *    board goes back to its state right after power-up -- no 
  342.  *    micro-code or anything.
  343.  *
  344.  * Results:
  345.  *    SUCCESS if a reply was received properly, FAILURE otherwise
  346.  *
  347.  * Side effects:
  348.  *    The ultranet adapter is initialized.
  349.  *
  350.  *----------------------------------------------------------------------
  351.  */
  352.  
  353. ReturnStatus
  354. NetUltraHardReset(interPtr)
  355.     Net_Interface    *interPtr;    /* Interface to reset. */
  356. {
  357.     NetUltraState    *statePtr;    /* State of the adapter. */
  358.     ReturnStatus    status = SUCCESS;
  359.     int            zero = 0;
  360.  
  361.     statePtr = (NetUltraState *) interPtr->interfaceData;
  362.     printf("Ultra: adapter reset.\n");
  363.     status = Mach_Probe(sizeof(int), (char *) &zero, 
  364.         (char *) statePtr->resetReg);
  365.     if (status != SUCCESS) {
  366.     /*
  367.      * Adapter is no longer responding.
  368.      */
  369.     printf("NetUltraHardReset: adapter did not respond to reset!!\n");
  370.     statePtr->flags = 0;
  371.     return FAILURE;
  372.     }
  373.     MACH_DELAY(NET_ULTRA_RESET_DELAY);
  374.     InitQueues(statePtr);
  375.     /*
  376.      * After a reset the adapter is in the EPROM mode.
  377.      * This allows several additional commands (load, go, etc.) to be
  378.      * sent to the adapter.
  379.      */
  380.     statePtr->flags = NET_ULTRA_STATE_EXIST | NET_ULTRA_STATE_EPROM;
  381.     return status;
  382. }
  383.  
  384. /*
  385.  *----------------------------------------------------------------------
  386.  *
  387.  * NetUltraInitAdapter --
  388.  *
  389.  *    Allocate the various queues and send the initialization command
  390.  *    to the adapter.
  391.  *
  392.  * Results:
  393.  *    Standard Sprite return status.
  394.  *
  395.  * Side effects:
  396.  *    The adapter board is initialized.
  397.  *
  398.  *----------------------------------------------------------------------
  399.  */
  400.  
  401. ReturnStatus
  402. NetUltraInitAdapter(statePtr)
  403.     NetUltraState    *statePtr;    /* State of the adapter. */
  404. {
  405.     ReturnStatus    status;
  406.     NetUltraInitCommand    cmd;        /* Init command block. */
  407.     Net_Interface    *interPtr;
  408.  
  409.     interPtr = statePtr->interPtr;
  410.     MASTER_LOCK(&interPtr->mutex);
  411.     if (!(statePtr->flags & NET_ULTRA_STATE_GO)) {
  412.     if (netUltraDebug) {
  413.         printf("NetUltraInitAdapter: device is not started.\n");
  414.     }
  415.     status = FAILURE;
  416.     goto exit;
  417.     }
  418.     bzero((char *) &cmd, sizeof(cmd));
  419.     cmd.opcode = NET_ULTRA_INIT_OPCODE;
  420.     cmd.toAdapterAddr = (int) DVMA_TO_VME(statePtr->firstToAdapterPtr, 
  421.                     statePtr);
  422.     cmd.toAdapterNum = statePtr->lastToAdapterPtr - 
  423.             statePtr->firstToAdapterPtr + 1;
  424.     cmd.toHostAddr = (int) DVMA_TO_VME(statePtr->firstToHostPtr, statePtr);
  425.     cmd.toHostNum = statePtr->lastToHostPtr - statePtr->firstToHostPtr + 1;
  426.     cmd.XRBSize = sizeof(NetUltraXRB);
  427.     cmd.priority = (char) statePtr->priority;
  428.     cmd.vector = (char) interPtr->vector;
  429.     cmd.requestLevel = (char) statePtr->requestLevel;
  430.     cmd.addressSpace = (char) statePtr->addressSpace;
  431.     status = NetUltraSendCmd(statePtr, NET_ULTRA_INIT_OK, sizeof(cmd), 
  432.             (Address) &cmd);
  433.     if (status != SUCCESS) {
  434.     if (cmd.reply == NET_ULTRA_BAD_SIZE) {
  435.         printf("NetUltraInitAdapter: adapter disagrees on size of XRB\n");
  436.     }
  437.     goto exit;
  438.     }
  439.     statePtr->flags &= ~NET_ULTRA_STATE_GO;
  440.     statePtr->flags |= NET_ULTRA_STATE_INIT;
  441. exit:
  442.     MASTER_UNLOCK(&interPtr->mutex);
  443.     return status;
  444. } 
  445.  
  446. /*
  447.  *----------------------------------------------------------------------
  448.  *
  449.  * NetUltraStart--
  450.  *
  451.  *    Send a start request to the board.
  452.  *    Assumes the interface mutex is held.
  453.  *
  454.  * Results:
  455.  *    Standard Sprite return status.
  456.  *
  457.  * Side effects:
  458.  *    A start request is sent to the board.
  459.  *
  460.  *----------------------------------------------------------------------
  461.  */
  462.  
  463. ReturnStatus
  464. NetUltraStart(statePtr)
  465.     NetUltraState    *statePtr;    /* State of the adapter. */
  466. {
  467.     NetUltraRequest        request;
  468.     NetUltraStartRequest    *startPtr;
  469.     NetUltraRequestHdr        *hdrPtr;
  470.     Net_Interface        *interPtr;
  471.     int                i;
  472.     int                power = 0;
  473.     int                tmp;
  474.     ReturnStatus        status = SUCCESS;
  475.     static int            sequence = 0;
  476.     Sync_Condition        startComplete;
  477.  
  478.     interPtr = statePtr->interPtr;
  479.     startPtr = &request.start;
  480.     hdrPtr = &startPtr->hdr;
  481.     if (Net_AddrCmp(&interPtr->netAddress[NET_PROTO_RAW],
  482.         &netZeroAddress)){
  483.     printf(
  484. "NetUltraStart: can't send start command - adapter address not set\n");
  485.     status = FAILURE;
  486.     goto exit;
  487.     }
  488.     if (statePtr->flags & NET_ULTRA_STATE_START) {
  489.     printf("NetUltraStart: adapter already started.\n");
  490.     status = FAILURE;
  491.     goto exit;
  492.     }
  493.     if (!(statePtr->flags & NET_ULTRA_STATE_INIT)) {
  494.     printf("NetUltraStart: adapter not initialized.\n");
  495.     status = FAILURE;
  496.     goto exit;
  497.     }
  498.     bzero((char *) &request, sizeof(request));
  499.     hdrPtr->cmd = NET_ULTRA_NEW_START_REQ;
  500.     startPtr->sequence = sequence;
  501.     sequence++;
  502.     startPtr->hostType = NET_ULTRA_START_HOSTTYPE_SUN;
  503.     /*
  504.      * Determine which power of 2 equals the maximum packet size. 
  505.      */
  506.     tmp = interPtr->maxBytes;
  507.     for (i = 0; i < sizeof(int) * 8; i++) {
  508.     if (tmp & 1) {
  509.         power = i;
  510.     }
  511.     tmp >>= 1;
  512.     }
  513.     if (1 << power > interPtr->maxBytes) {
  514.     power++;
  515.     }
  516.     startPtr->hostMaxBytes = power;
  517.     /* 
  518.      * This part is kind of goofy.  The adapter expects the network
  519.      * address to be 7 bytes long (the first byte is missing). We have
  520.      * to bcopy the netAddress minus its first byte.
  521.      */
  522.     startPtr->netAddressSize = 7;
  523.     bcopy(&(((char *) &interPtr->netAddress[NET_PROTO_RAW])[1]),
  524.     (char *) &startPtr->netAddressBuf, sizeof(Net_UltraAddress)-1);
  525.     startPtr->netAddressBuf[0] = 0x49;
  526.     startPtr->netAddressBuf[5] = 0xfe;
  527.     status = NetUltraSendReq(statePtr, StandardDone, 
  528.         (ClientData) &startComplete, FALSE, 
  529.         0, (Net_ScatterGather *) NIL, sizeof(NetUltraStartRequest), 
  530.         &request);
  531.     if (status != SUCCESS) {
  532.     printf("NetUltraStart: unable to send start request\n");
  533.     goto exit;
  534.     }
  535.     Sync_MasterWait(&(startComplete), &(interPtr->mutex), FALSE);
  536.     if (hdrPtr->status & NET_ULTRA_STATUS_OK) {
  537.     if (netUltraDebug) {
  538.         printf("NetUltraStart: hdrPtr->status = %d : %s\n",
  539.         hdrPtr->status, GetStatusString(hdrPtr->status));
  540.     }
  541.     if (netUltraDebug) {
  542.         printf("Ultranet adapter started\n");
  543.         printf("Ucode %d\n", startPtr->ucodeRel);
  544.         printf("Adapter type %d, adapter hw %d\n", startPtr->adapterType,
  545.         startPtr->adapterHW);
  546.         printf("Max VC = %d\n", startPtr->maxVC);
  547.         printf("Max DRCV = %d\n", startPtr->maxDRCV);
  548.         printf("Max DSND = %d\n", startPtr->maxDSND);
  549.         printf("Slot = %d\n", startPtr->slot);
  550.         printf("Speed = %d\n", startPtr->speed);
  551.         printf("Max bytes = %d\n", startPtr->adapterMaxBytes);
  552.     }
  553.     if (startPtr->maxDRCV < statePtr->maxReadPending) {
  554.         printf("NetUltraStart: WARNING: max pending reads reset to %d\n",
  555.         startPtr->maxDRCV);
  556.         statePtr->maxReadPending = startPtr->maxDRCV;
  557.     }
  558.     if (startPtr->maxDSND < statePtr->maxWritePending) {
  559.         printf("NetUltraStart: WARNING: max pending writes reset to %d\n",
  560.         startPtr->maxDSND);
  561.         statePtr->maxWritePending = startPtr->maxDSND;
  562.     }
  563.     if (startPtr->adapterMaxBytes < power) {
  564.         interPtr->maxBytes = 1 << power;
  565.         printf("NetUltraStart: WARNING: max bytes reset to %d\n",
  566.         interPtr->maxBytes);
  567.     }
  568.     statePtr->flags = (NET_ULTRA_STATE_EXIST | NET_ULTRA_STATE_START |
  569.                 NET_ULTRA_STATE_NORMAL);
  570.     /*
  571.      * Now queue up pending reads. 
  572.      */
  573.     for (i = 0; i < statePtr->maxReadPending; i++) {
  574.         List_Links        *itemPtr;
  575.         Address    buffer;
  576.         itemPtr = List_First(statePtr->freeBufferList);
  577.         if (itemPtr == statePtr->freeBufferList) {
  578.         panic("NetUltraOutput: list screwup\n");
  579.         }
  580.         List_Remove(itemPtr);
  581.         buffer = BUFFER_TO_DVMA(itemPtr, statePtr);
  582.         status = NetUltraPendingRead(interPtr, statePtr->bufferSize,
  583.             buffer);
  584.         if (status != SUCCESS) {
  585.         printf("NetUltraStart: could not queue pending read.\n");
  586.         }
  587.     }
  588.     } else {
  589.     printf("NetUltraStart: start command failed <0x%x> : %s\n",
  590.         hdrPtr->status, GetStatusString(hdrPtr->status));
  591.     }
  592. exit:
  593.     return status;
  594. }
  595.  
  596. /*
  597.  *----------------------------------------------------------------------
  598.  *
  599.  * StandardDone --
  600.  *
  601.  *    This is a callback routine that is called from the interrupt
  602.  *    handler when "standard" commands complete. It copies the request
  603.  *    from the XRB in the queue to the request structure pointed
  604.  *    to by the XRB.  This allows the XRB to be used again.
  605.  *    If the data field in the info structure is not NIL then it
  606.  *    is assumed to be a pointer to a condition variable and a
  607.  *    broadcast is done on that variable.
  608.  *
  609.  *
  610.  * Results:
  611.  *    None.
  612.  *
  613.  * Side effects:
  614.  *    None.
  615.  *    
  616.  *
  617.  *----------------------------------------------------------------------
  618.  */
  619.  
  620. /* ARGSUSED */
  621. static void
  622. StandardDone(interPtr, infoPtr)
  623.     Net_Interface    *interPtr;    /* Interface. */
  624.     NetUltraXRBInfo    *infoPtr;    /* Info about XRB that completed. */
  625. {
  626.     bcopy((char *) &infoPtr->xrbPtr->request, (char *) infoPtr->requestPtr,
  627.     infoPtr->requestSize);
  628.     if (infoPtr->doneData != (ClientData) NIL) {
  629.     Sync_Broadcast((Sync_Condition *) infoPtr->doneData);
  630.     }
  631. }
  632.  
  633. /*
  634.  *----------------------------------------------------------------------
  635.  *
  636.  * NetUltraStop--
  637.  *
  638.  *    Send a stop request to the board.
  639.  *    Assumes the interface mutex is held.
  640.  *
  641.  * Results:
  642.  *    Standard Sprite return status.
  643.  *
  644.  * Side effects:
  645.  *    The adapter abandons what it is doing.
  646.  *
  647.  *----------------------------------------------------------------------
  648.  */
  649.  
  650. ReturnStatus
  651. NetUltraStop(statePtr)
  652.     NetUltraState    *statePtr;    /* State of the adapter. */
  653. {
  654.     NetUltraRequest        request;
  655.     NetUltraStopRequest        *stopPtr;
  656.     NetUltraRequestHdr        *hdrPtr;
  657.     Net_Interface        *interPtr;
  658.     ReturnStatus        status = SUCCESS;
  659.     Sync_Condition        stopComplete;
  660.  
  661.     interPtr = statePtr->interPtr;
  662.     stopPtr = &request.stop;
  663.     hdrPtr = &stopPtr->hdr;
  664.     if (!(statePtr->flags & NET_ULTRA_STATE_START)) {
  665.     printf("NetUltraStop: adapter not started.\n");
  666.     status = FAILURE;
  667.     goto exit;
  668.     }
  669.     bzero((char *) &request, sizeof(request));
  670.     hdrPtr->cmd = NET_ULTRA_STOP_REQ;
  671.     status = NetUltraSendReq(statePtr, StandardDone, 
  672.         (ClientData) &stopComplete, FALSE,
  673.         0, (Net_ScatterGather *) NIL, sizeof(NetUltraStopRequest), 
  674.         &request);
  675.     if (status != SUCCESS) {
  676.     printf("NetUltraStop: unable to send stop request\n");
  677.     goto exit;
  678.     }
  679.     Sync_MasterWait(&(stopComplete), &(interPtr->mutex), FALSE);
  680.     if (hdrPtr->status & NET_ULTRA_STATUS_OK) {
  681.     if (netUltraDebug) {
  682.         printf("NetUltraStop: hdrPtr->status = %d : %s\n",
  683.         hdrPtr->status, GetStatusString(hdrPtr->status));
  684.     }
  685.     statePtr->flags &= ~NET_ULTRA_STATE_START;
  686.     } else {
  687.     printf("NetUltraStop: stop command failed <0x%x> : %s\n",
  688.         hdrPtr->status, GetStatusString(hdrPtr->status));
  689.     }
  690. exit:
  691.     return status;
  692. }
  693.  
  694. /*
  695.  *----------------------------------------------------------------------
  696.  *
  697.  * NetUltraReset --
  698.  *
  699.  *    Resets the board by sending it a stop command followed by a
  700.  *    start command.  The XRB queues are also initialized.
  701.  *    Assumes the interface mutex is held.
  702.  *
  703.  * Results:
  704.  *    A standard Sprite return status.
  705.  *
  706.  * Side effects:
  707.  *    None.
  708.  *
  709.  *----------------------------------------------------------------------
  710.  */
  711.  
  712. ReturnStatus
  713. NetUltraReset(interPtr)
  714.     Net_Interface    *interPtr;    /* Interface to reset. */
  715. {
  716.     ReturnStatus    status = SUCCESS;
  717.     NetUltraState    *statePtr;    /* State of the adapter. */
  718.  
  719.     statePtr = (NetUltraState *) interPtr->interfaceData;
  720.     status = NetUltraStop(statePtr);
  721.     if (status != NULL) {
  722.     printf("NetUltraReset: stop failed\n");
  723.     return status;
  724.     }
  725.     InitQueues(statePtr);
  726.     status = NetUltraStart(statePtr);
  727.     if (status != NULL) {
  728.     printf("NetUltraReset: start failed\n");
  729.     return status;
  730.     }
  731.     return status;
  732. }
  733.  
  734. /*
  735.  *----------------------------------------------------------------------
  736.  *
  737.  * Net_UltraReset --
  738.  *
  739.  *    This is a version of the reset routine that can be called
  740.  *     from outside the module since it locks the mutex.
  741.  *
  742.  * Results:
  743.  *    
  744.  *
  745.  * Side effects:
  746.  *    None.
  747.  *
  748.  *----------------------------------------------------------------------
  749.  */
  750.  
  751. void
  752. Net_UltraReset(interPtr)
  753.     Net_Interface    *interPtr;    /* Interface to reset. */
  754. {
  755.     MASTER_LOCK(&interPtr->mutex);
  756.     /*
  757.      * If we are at interrupt level we have to do a callback to reset
  758.      * the adapter since we can't wait for the response from
  759.      * the adapter (there may not be a current process and we can't
  760.      * get the interrupt).
  761.      */
  762.     if (Mach_AtInterruptLevel()) {
  763.     Proc_CallFunc(NetUltraResetCallback, (ClientData) interPtr, 0);
  764.     } else {
  765.     (void) NetUltraReset(interPtr);
  766.     }
  767.     MASTER_UNLOCK(&interPtr->mutex);
  768. }
  769.  
  770. /*
  771.  *----------------------------------------------------------------------
  772.  *
  773.  * NetUltraResetCallback --
  774.  *
  775.  *    This routine is called by the Proc_ServerProc during the
  776.  *    callback to reset the adapter.
  777.  *
  778.  * Results:
  779.  *    None.
  780.  *
  781.  * Side effects:
  782.  *    The adapter is reset.
  783.  *
  784.  *----------------------------------------------------------------------
  785.  */
  786. /*ARGSUSED*/
  787. static void
  788. NetUltraResetCallback(data, infoPtr)
  789.     ClientData        data;        /* Ptr to the interface to reset. */
  790.     Proc_CallInfo    *infoPtr;    /* Unused. */
  791. {
  792.     Net_UltraReset((Net_Interface *) data);
  793. }
  794.  
  795.  
  796. /*
  797.  *----------------------------------------------------------------------
  798.  *
  799.  * Net_UltraHardReset --
  800.  *
  801.  *    This is a version of the hard reset routine that can be called from
  802.  *     outside the net module because it does not assume that a
  803.  *    lock is held (or interrupts are disabled) when it is called.
  804.  *
  805.  * Results:
  806.  *    None.
  807.  *
  808.  * Side effects:
  809.  *    The adapter is reset.
  810.  *
  811.  *----------------------------------------------------------------------
  812.  */
  813.  
  814. void
  815. Net_UltraHardReset(interPtr)
  816.     Net_Interface    *interPtr;    /* Interface to reset. */
  817. {
  818.     MASTER_LOCK(&interPtr->mutex);
  819.  
  820.     NetUltraHardReset(interPtr);
  821.  
  822.     MASTER_UNLOCK(&interPtr->mutex);
  823. }
  824.  
  825.  
  826. /*
  827.  *----------------------------------------------------------------------
  828.  *
  829.  * NetUltraDiag --
  830.  *
  831.  *    Send a diagnostic command to the adapter.
  832.  *
  833.  * Results:
  834.  *    SUCCESS if the adapter processed the command correctly,
  835.  *    FAILURE otherwise.
  836.  *
  837.  * Side effects:
  838.  *    The adapter is sent a diagnostic command.
  839.  *
  840.  *----------------------------------------------------------------------
  841.  */
  842.  
  843. ReturnStatus
  844. NetUltraDiag(statePtr, cmdPtr)
  845.     NetUltraState    *statePtr;    /* State of the adapter. */
  846.     NetUltraDiagCommand    *cmdPtr;    /* Diagnostic command block. */
  847. {
  848.     ReturnStatus        status = SUCCESS;
  849.     NetUltraDiagCommand        tmpCmd;    
  850.     int                inSize;
  851.     int                outSize;
  852.     int                fmtStatus;
  853.  
  854.     MASTER_LOCK(&statePtr->interPtr->mutex);
  855.     if (!(statePtr->flags & NET_ULTRA_STATE_EPROM)) {
  856.     if (netUltraDebug) {
  857.         printf("NetUltraDiag: device is not in EPROM state.\n");
  858.     }
  859.     status = FAILURE;
  860.     goto exit;
  861.     }
  862.     if (netUltraDebug) {
  863.     printf("Sending diagnostic command to adapter.\n");
  864.     }
  865.     bzero((char *) &tmpCmd, sizeof(tmpCmd));
  866.     tmpCmd.opcode = NET_ULTRA_DIAG_OPCODE;
  867.     status = NetUltraSendCmd(statePtr, NET_ULTRA_DIAG_OK, 
  868.             sizeof(tmpCmd), (Address) &tmpCmd);
  869.     if (status != SUCCESS) {
  870.     goto exit;
  871.     }
  872.     cmdPtr->reply = tmpCmd.reply;
  873.     cmdPtr->version = tmpCmd.version;
  874.     cmdPtr->error = tmpCmd.error;
  875.     /*
  876.      * The hardware related fields are returned in Intel 386 byte-order.
  877.      */
  878.     inSize = 5 * sizeof(int);
  879.     outSize = inSize;
  880.     fmtStatus = Fmt_Convert("w5", NET_ULTRA_FORMAT, &inSize, 
  881.             (char *) &(tmpCmd.hwModel), mach_Format, &outSize, 
  882.             (char *) &(cmdPtr->hwModel));
  883.     if (fmtStatus != 0) {
  884.     printf("NetUltraInfo: Format returned %d\n");
  885.     status = FAILURE;
  886.     goto exit;
  887.     }
  888. exit:
  889.     MASTER_UNLOCK(&statePtr->interPtr->mutex)
  890.     return status;
  891. }
  892.  
  893. /*
  894.  *----------------------------------------------------------------------
  895.  *
  896.  * NetUltraInfo --
  897.  *
  898.  *    Send an info command to the adapter. The results are the same
  899.  *     as the diagnostic command, except the diagnostics are not 
  900.  *    actually run.  Presumably we are fetching the results of the
  901.  *    last time diagnostics were run, probably due to a reset.
  902.  *
  903.  * Results:
  904.  *    SUCCESS if the adapter processed the command correctly,
  905.  *    FAILURE otherwise.
  906.  *
  907.  * Side effects:
  908.  *    The adapter is sent an info command.
  909.  *
  910.  *----------------------------------------------------------------------
  911.  */
  912.  
  913. ReturnStatus
  914. NetUltraInfo(statePtr, cmdPtr)
  915.     NetUltraState    *statePtr;    /* State of the adapter. */
  916.     NetUltraInfoCommand    *cmdPtr;    /* Info command block. */
  917. {
  918.     ReturnStatus        status = SUCCESS;
  919.     int                fmtStatus;
  920.     NetUltraInfoCommand        tmpCmd;
  921.     int                inSize;
  922.     int                outSize;
  923.  
  924.     MASTER_LOCK(&statePtr->interPtr->mutex);
  925.     if (!(statePtr->flags & NET_ULTRA_STATE_EPROM)) {
  926.     if (netUltraDebug) {
  927.         printf("NetUltraInfo: device is not in EPROM state.\n");
  928.     }
  929.     status = FAILURE;
  930.     goto exit;
  931.     }
  932.     if (netUltraDebug) {
  933.     printf("Sending Info command to adapter.\n");
  934.     }
  935.     bzero((char *) &tmpCmd, sizeof(NetUltraInfoCommand));
  936.     tmpCmd.opcode = NET_ULTRA_INFO_OPCODE;
  937.     status = NetUltraSendCmd(statePtr, NET_ULTRA_INFO_OK, 
  938.             sizeof(NetUltraInfoCommand), (Address) &tmpCmd);
  939.     if (status != SUCCESS) {
  940.     goto exit;
  941.     }
  942.     cmdPtr->reply = tmpCmd.reply;
  943.     cmdPtr->version = tmpCmd.version;
  944.     cmdPtr->error = tmpCmd.error;
  945.     /*
  946.      * The hardware related fields are returned in Intel 386 byte-order.
  947.      */
  948.     inSize = 5 * sizeof(int);
  949.     outSize = inSize;
  950.     fmtStatus = Fmt_Convert("w5", NET_ULTRA_FORMAT, &inSize, 
  951.             (char *) &(tmpCmd.hwModel), mach_Format, &outSize, 
  952.             (char *) &(cmdPtr->hwModel));
  953.     if (fmtStatus != 0) {
  954.     printf("NetUltraInfo: Format returned %d\n");
  955.     status = FAILURE;
  956.     }
  957. exit:
  958.     MASTER_UNLOCK(&statePtr->interPtr->mutex)
  959.     return status;
  960. }
  961.  
  962. /*
  963.  *----------------------------------------------------------------------
  964.  *
  965.  * NetUltraExtDiag --
  966.  *
  967.  *    Send an extended diagnostic command to the adapter.
  968.  *
  969.  * Results:
  970.  *    SUCCESS if the adapter processed the command correctly,
  971.  *    FAILURE otherwise.
  972.  *
  973.  * Side effects:
  974.  *    The adapter is sent an extended diagnostic command.
  975.  *
  976.  *----------------------------------------------------------------------
  977.  */
  978.  
  979. ReturnStatus
  980. NetUltraExtDiag(statePtr, external, buffer, cmdPtr)
  981.     NetUltraState    *statePtr;    /* State of the adapter. */
  982.     Boolean        external;    /* TRUE => use external loopback
  983.                      * adapter. */
  984.     char        buffer[];     /* Used for VME tests. */
  985.     NetUltraExtDiagCommand    *cmdPtr;    /* Extended diagnostic command
  986.                          * block. */
  987. {
  988.     ReturnStatus        status = SUCCESS;
  989.     Address            bufAddress;
  990.  
  991.     MASTER_LOCK(&statePtr->interPtr->mutex);
  992.     if (!(statePtr->flags & NET_ULTRA_STATE_EPROM)) {
  993.     if (netUltraDebug) {
  994.         printf("NetUltraExtDiag: device is not in EPROM state.\n");
  995.     }
  996.     status = FAILURE;
  997.     goto exit;
  998.     }
  999.     if (netUltraDebug) {
  1000.     printf("Sending extended diagnostic command to adapter.\n");
  1001.     }
  1002.     bufAddress = (Address) VmMach_DMAAlloc(NET_ULTRA_EXT_DIAG_BUF_SIZE, buffer);
  1003.     if (bufAddress == (Address) NIL) {
  1004.     printf("NetUltraExtDiag: unable to allocate buffer in DMA space.\n");
  1005.     status = FAILURE;
  1006.     }
  1007.     bzero((char *) cmdPtr, sizeof(*cmdPtr));
  1008.     cmdPtr->opcode = NET_ULTRA_EXT_DIAG_OPCODE;
  1009.     cmdPtr->externalLoopback = (external == TRUE) ? 1 : 0;
  1010.     cmdPtr->bufferAddress = (int) DVMA_TO_VME(bufAddress, statePtr);
  1011.     status = NetUltraSendCmd(statePtr, NET_ULTRA_EXT_DIAG_OK, sizeof(*cmdPtr), 
  1012.         (Address) cmdPtr);
  1013.     VmMach_DMAFree(NET_ULTRA_EXT_DIAG_BUF_SIZE, bufAddress);
  1014. exit:
  1015.     MASTER_UNLOCK(&statePtr->interPtr->mutex);
  1016.     return status;
  1017. }
  1018.  
  1019. /*
  1020.  *----------------------------------------------------------------------
  1021.  *
  1022.  * NetUltraLoad --
  1023.  *
  1024.  *    Download a block of ucode onto the adapter.
  1025.  *
  1026.  * Results:
  1027.  *    SUCCESS if the command was processed properly
  1028.  *
  1029.  * Side effects:
  1030.  *    Data is loaded into the adapter ram.
  1031.  *
  1032.  *----------------------------------------------------------------------
  1033.  */
  1034.  
  1035. ReturnStatus
  1036. NetUltraLoad(statePtr, address, length, ucodePtr)
  1037.     NetUltraState    *statePtr;    /* State of the adapter. */
  1038.     int            address;    /* Load address of ucode. */
  1039.     int            length;        /* Size of ucode. */
  1040.     Address        ucodePtr;    /* Ucode buffer. */
  1041. {
  1042.     NetUltraLoadCommand        cmd;
  1043.     int                inSize;
  1044.     int                outSize;
  1045.     int                fmtStatus;
  1046.     Address            dmaAddress;
  1047.     ReturnStatus        status = SUCCESS;
  1048.  
  1049.     MASTER_LOCK(&statePtr->interPtr->mutex);
  1050.     if (!(statePtr->flags & NET_ULTRA_STATE_EPROM)) {
  1051.     if (netUltraDebug) {
  1052.         printf("NetUltraExtDiag: device is not in EPROM state.\n");
  1053.     }
  1054.     status = FAILURE;
  1055.     goto exit;
  1056.     }
  1057.     if (netUltraDebug) {
  1058.     printf("Sending load command to adapter.\n");
  1059.     printf("Address = 0x%x, length = %d\n", address, length);
  1060.     }
  1061.     /*
  1062.      * Convert the address and length to Intel format.
  1063.      */
  1064.     inSize = sizeof(int);
  1065.     outSize = sizeof(int);
  1066.     fmtStatus = Fmt_Convert("w", mach_Format, &inSize,
  1067.             (char *) &address, NET_ULTRA_FORMAT, &outSize,
  1068.             (char *) &(cmd.loadAddress));
  1069.     if (fmtStatus != 0) {
  1070.     printf("NetUltraLoad: Fmt_Convert returned %d\n",
  1071.         fmtStatus);
  1072.     status = FAILURE;
  1073.     goto exit;
  1074.     }
  1075.     inSize = sizeof(int);
  1076.     outSize = sizeof(int);
  1077.     fmtStatus = Fmt_Convert("w", mach_Format, &inSize,
  1078.             (char *) &length, NET_ULTRA_FORMAT, &outSize,
  1079.             (char *) &(cmd.length));
  1080.     if (fmtStatus != 0) {
  1081.     printf("NetUltraLoad: Fmt_Convert returned %d\n",
  1082.         fmtStatus);
  1083.     status = FAILURE;
  1084.     goto exit;
  1085.     }
  1086.     cmd.opcode = NET_ULTRA_LOAD_OPCODE;
  1087.     cmd.reply = 0;
  1088.     /*
  1089.      * Map the ucode into DVMA space.
  1090.      */
  1091.     dmaAddress = (Address) VmMach_DMAAlloc(length, ucodePtr); 
  1092.     cmd.dataAddress = (unsigned long) DVMA_TO_VME(dmaAddress, statePtr);
  1093.     status = NetUltraSendCmd(statePtr, NET_ULTRA_LOAD_OK, sizeof(cmd), 
  1094.         (Address) &cmd);
  1095.     VmMach_DMAFree(length, dmaAddress);
  1096.     if (status != SUCCESS) {
  1097.     goto exit;
  1098.     }
  1099.     statePtr->flags |= NET_ULTRA_STATE_LOAD;
  1100. exit:
  1101.     MASTER_UNLOCK(&statePtr->interPtr->mutex)
  1102.     return status;
  1103. }
  1104.  
  1105. /*
  1106.  *----------------------------------------------------------------------
  1107.  *
  1108.  * NetUltraGo --
  1109.  *
  1110.  *    Send the go command to the adapter to start its processor
  1111.  *    running the ucode.
  1112.  *
  1113.  * Results:
  1114.  *    SUCCESS if it worked, FAILURE otherwise
  1115.  *
  1116.  * Side effects:
  1117.  *    The adapter cpu begins executing.
  1118.  *
  1119.  *----------------------------------------------------------------------
  1120.  */
  1121.  
  1122. ReturnStatus
  1123. NetUltraGo(statePtr, address)
  1124.     NetUltraState    *statePtr;    /* State of the adapter. */
  1125.     int            address;    /* Start address. */
  1126. {
  1127.     NetUltraGoCommand        cmd;
  1128.     int                inSize;
  1129.     int                outSize;
  1130.     int                fmtStatus;
  1131.     ReturnStatus        status = SUCCESS;
  1132.  
  1133.     MASTER_LOCK(&statePtr->interPtr->mutex);
  1134.     if (!(statePtr->flags & NET_ULTRA_STATE_EPROM)) {
  1135.     if (netUltraDebug) {
  1136.         printf("NetUltraExtDiag: device is not in EPROM state.\n");
  1137.     }
  1138.     status = FAILURE;
  1139.     goto exit;
  1140.     }
  1141.     if (!(statePtr->flags & NET_ULTRA_STATE_LOAD)) {
  1142.     if (netUltraDebug) {
  1143.         printf("NetUltraGo: ucode not downloaded.\n");
  1144.     }
  1145.     status = FAILURE;
  1146.     goto exit;
  1147.     }
  1148.     if (netUltraDebug) {
  1149.     printf("Sending go command to adapter.\n");
  1150.     }
  1151.     /*
  1152.      * Convert the address into Intel format.
  1153.      */
  1154.     inSize = sizeof(int);
  1155.     outSize = sizeof(int);
  1156.     fmtStatus = Fmt_Convert("w", mach_Format, &inSize,
  1157.             (char *) &address, NET_ULTRA_FORMAT, &outSize,
  1158.             (char *) &(cmd.startAddress));
  1159.     if (fmtStatus != 0) {
  1160.     printf("NetUltraGo: Fmt_Convert returned %d\n",
  1161.         fmtStatus);
  1162.     status = FAILURE;
  1163.     goto exit;
  1164.     }
  1165.     cmd.opcode = NET_ULTRA_GO_OPCODE;
  1166.     cmd.reply = 0;
  1167.     status = NetUltraSendCmd(statePtr, NET_ULTRA_GO_OK, sizeof(cmd), 
  1168.         (Address) &cmd);
  1169.     if (status != SUCCESS) {
  1170.     goto exit;
  1171.     }
  1172.     statePtr->flags &= ~NET_ULTRA_STATE_LOAD;
  1173.     statePtr->flags |= NET_ULTRA_STATE_GO;
  1174.     statePtr->flags &= ~NET_ULTRA_STATE_EPROM;
  1175. exit:
  1176.     MASTER_UNLOCK(&statePtr->interPtr->mutex)
  1177.     return status;
  1178. }
  1179.  
  1180.  
  1181. /*
  1182.  *----------------------------------------------------------------------
  1183.  *
  1184.  * NetUltraSendCmd --
  1185.  *
  1186.  *    Send a command to the adapter.
  1187.  *
  1188.  * Results:
  1189.  *    SUCCESS if the adapter responded to the command,
  1190.  *    DEV_TIMEOUT if the adapter did not respond
  1191.  *
  1192.  * Side effects:
  1193.  *    A command is sent to the adapter.
  1194.  *
  1195.  *----------------------------------------------------------------------
  1196.  */
  1197.  
  1198. ReturnStatus
  1199. NetUltraSendCmd(statePtr, ok,size, cmdPtr)
  1200.     NetUltraState    *statePtr;    /* State of the adapter. */
  1201.     int            ok;        /* Value of reply field if command
  1202.                      * was successful. */
  1203.     int            size;        /* Size of command block. */
  1204.     Address        cmdPtr;        /* The command block. */
  1205. {
  1206.     struct StdCmd {
  1207.     volatile int        opcode;
  1208.     volatile int        reply;
  1209.     } *stdCmdPtr;
  1210.     ReturnStatus    status = SUCCESS;
  1211.  
  1212.     stdCmdPtr = (struct StdCmd *) cmdPtr;
  1213.     if (netUltraDebug) {
  1214.     printf("NetUltraSendCmd: sending command %d to adapter\n",
  1215.         stdCmdPtr->opcode);
  1216.     printf("NetUltraSendCmd: cmdPtr = 0x%x\n", cmdPtr);
  1217.     }
  1218.     if ((int) cmdPtr & 0x3) {
  1219.     panic("NetUltraSendCmd: command not aligned on a word boundary\n");
  1220.     }
  1221.     stdCmdPtr->reply = 0;
  1222.     cmdPtr = VmMach_DMAAlloc(size, cmdPtr);
  1223.     if (cmdPtr == (Address) NIL) {
  1224.     panic("NetUltraSendCmd: can't allocate DMA space for command\n");
  1225.     }
  1226.     if (netUltraDebug) {
  1227.     printf("NetUltraSendCmd: cmdPtr mapped into DMA space\n");
  1228.     printf("NetUltraSendCmd: cmdPtr = 0x%x\n", cmdPtr);
  1229.     }
  1230.     *statePtr->intrReg = 
  1231.     (int) DVMA_TO_VME(cmdPtr,statePtr);
  1232.     WAIT_FOR_REPLY(&stdCmdPtr->reply, NET_ULTRA_DELAY);
  1233.     VmMach_DMAFree(size, cmdPtr);
  1234.     if (stdCmdPtr->reply == 0) {
  1235.     printf("NetUltraSendCmd: adapter timed out\n");
  1236.     status = DEV_TIMEOUT;
  1237.     } else if (stdCmdPtr->reply == ok) {
  1238.     status = SUCCESS;
  1239.     } else {
  1240.     printf("NetUltraSendCmd: adapter returned %d\n", stdCmdPtr->reply);
  1241.     status = FAILURE;
  1242.     }
  1243.     return status;
  1244. }
  1245.  
  1246. /*
  1247.  *----------------------------------------------------------------------
  1248.  *
  1249.  * NetUltraIntr --
  1250.  *
  1251.  *    Handle an interrupt from the Ultranet adapter.
  1252.  *
  1253.  * Results:
  1254.  *    None.
  1255.  *
  1256.  * Side effects:
  1257.  *    None.
  1258.  *
  1259.  *----------------------------------------------------------------------
  1260.  */
  1261.  
  1262. /*ARGSUSED*/
  1263. void
  1264. NetUltraIntr(interPtr, polling)
  1265.     Net_Interface    *interPtr;    /* Interface to process. */
  1266.     Boolean        polling;    /* TRUE if are being polled instead of
  1267.                      * processing an interrupt. */
  1268. {
  1269.     NetUltraXRB        *xrbPtr;
  1270.     NetUltraXRB        *nextXRBPtr;
  1271.     NetUltraState    *statePtr;
  1272.     NetUltraDMAInfo    *dmaPtr;
  1273.     NetUltraRequestHdr  *hdrPtr;
  1274.     NetUltraXRBInfo    *infoPtr;
  1275.     int            processed;
  1276.     NetUltraTraceInfo    *tracePtr;
  1277.     Address        buffer;
  1278.  
  1279.     MASTER_LOCK(&interPtr->mutex);
  1280. #ifndef CLEAN
  1281.     if (netUltraDebug) {
  1282.     printf("Received an Ultranet interrupt.\n");
  1283.     }
  1284. #endif
  1285.     statePtr = (NetUltraState *) interPtr->interfaceData;
  1286.     xrbPtr = statePtr->nextToHostPtr;
  1287. #ifndef CLEAN
  1288.     if (netUltraTrace) {
  1289.     NEXT_TRACE(statePtr, &tracePtr);
  1290.     tracePtr->event = INTERRUPT;
  1291.     Timer_GetCurrentTicks(&tracePtr->ticks);
  1292.     }
  1293. #endif
  1294.     processed = 0;
  1295.     while(xrbPtr->filled != 0) {
  1296.     /*
  1297.      * Compute the next xrb to the host.
  1298.      */
  1299.     if (xrbPtr == statePtr->lastToHostPtr) {
  1300.         nextXRBPtr = statePtr->firstToHostPtr;
  1301.     } else {
  1302.         nextXRBPtr = xrbPtr + 1;
  1303.     }
  1304.     statePtr->nextToHostPtr = nextXRBPtr;
  1305.     dmaPtr = &xrbPtr->dma;
  1306.     if (!(dmaPtr->cmd & NET_ULTRA_DMA_CMD_FROM_ADAPTER)) {
  1307.         printf("NetUltraIntr: cmd (0x%x) not from adapter?\n", dmaPtr->cmd);
  1308.         goto endLoop;
  1309.     }
  1310.     if ((dmaPtr->cmd & NET_ULTRA_DMA_CMD_MASK) != NET_ULTRA_DMA_CMD_XRB) {
  1311.         printf("NetUltraIntr: dmaPtr->cmd = 0x%x\n", dmaPtr->cmd);
  1312.         goto endLoop;
  1313.     }
  1314.     hdrPtr = (NetUltraRequestHdr *) &xrbPtr->request;
  1315.     infoPtr = hdrPtr->infoPtr;
  1316.     if (infoPtr->flags & NET_ULTRA_INFO_PENDING) {
  1317. #ifndef CLEAN
  1318.         if (netUltraDebug) {
  1319.         printf("NetUltraIntr: processing 0x%x\n", infoPtr);
  1320.         }
  1321.         if (netUltraTrace) {
  1322.         NEXT_TRACE(statePtr, &tracePtr);
  1323.         tracePtr->event = PROCESS_XRB;
  1324.         tracePtr->index = xrbPtr - statePtr->firstToHostPtr;
  1325.         tracePtr->infoPtr = infoPtr;
  1326.         Timer_GetCurrentTicks(&tracePtr->ticks);
  1327.         }
  1328. #endif
  1329.         infoPtr->xrbPtr = xrbPtr;
  1330.         if (statePtr->flags & NET_ULTRA_STATE_STATS) {
  1331.         if (hdrPtr->cmd == NET_ULTRA_DGRAM_RECV_REQ) {
  1332.             statePtr->stats.packetsReceived++;
  1333.             statePtr->stats.bytesReceived += hdrPtr->size;
  1334.             statePtr->stats.receivedHistogram[hdrPtr->size >> 10]++;
  1335.         }
  1336.         }
  1337.         /*
  1338.          * Mark the info as not pending.
  1339.          * Clearing the pending bit ensures
  1340.          * that this packet does not get processed twice, since the
  1341.          * master lock around the interface will get released before
  1342.          * calling the RPC system, so that the RPC system can
  1343.          * output a packet. Do not
  1344.          * clear the filled bit since we are using the contents of
  1345.          * the xrb and we don't want the adapter to overwrite it
  1346.          * yet. 
  1347.          */
  1348.         infoPtr->flags &= ~NET_ULTRA_INFO_PENDING;
  1349.         if (infoPtr->doneProc != NILPROC) {
  1350.         (infoPtr->doneProc)(interPtr, infoPtr);
  1351.         }
  1352.         if (infoPtr->flags & NET_ULTRA_INFO_STD_BUFFER) {
  1353.         if (infoPtr->flags & NET_ULTRA_INFO_REMAP) {
  1354.             VmMach_DMAFree(hdrPtr->size, 
  1355.             VME_TO_DVMA(hdrPtr->buffer, statePtr));
  1356.             buffer = infoPtr->buffer;
  1357.         } else {
  1358.             buffer = VME_TO_BUFFER(hdrPtr->buffer, statePtr);
  1359.         }
  1360.         List_InitElement((List_Links *) buffer);
  1361.         List_Insert((List_Links *) buffer,
  1362.                LIST_ATREAR(statePtr->freeBufferList));
  1363.         }
  1364.         List_Remove((List_Links *) infoPtr);
  1365.         List_Insert((List_Links *) infoPtr, 
  1366.         LIST_ATREAR(statePtr->freeXRBInfoList));
  1367.         processed++;
  1368.     } else {
  1369. #ifndef CLEAN
  1370.         if (netUltraTrace) {
  1371.         NEXT_TRACE(statePtr, &tracePtr);
  1372.         tracePtr->event = INFO_NOT_PENDING;
  1373.         tracePtr->index = xrbPtr - statePtr->firstToHostPtr;
  1374.         tracePtr->infoPtr = infoPtr;
  1375.         }
  1376. #endif
  1377.     }
  1378. endLoop: 
  1379.     xrbPtr->filled = 0;
  1380.     xrbPtr = nextXRBPtr;
  1381.     /*
  1382.      * Check and see if there is a free xrb in the "to adapter"
  1383.      * queue.  Presumably the appearance of one in the "to host"
  1384.      * queue implies one freed up in the "to adapter" queue.
  1385.      */
  1386.     if ((statePtr->nextToAdapterPtr->filled != 0) && 
  1387.         (statePtr->toAdapterAvail.waiting == TRUE)) {
  1388.         Sync_Broadcast(&statePtr->toAdapterAvail);
  1389.     }
  1390.     }
  1391. #ifndef CLEAN
  1392.     if (processed == 0) {
  1393.     if (netUltraDebug) {
  1394.         printf("NetUltraIntr: didn't process any packets.\n");
  1395.     }
  1396.     }
  1397. #endif
  1398.     MASTER_UNLOCK(&interPtr->mutex);
  1399. }
  1400.  
  1401. /*
  1402.  *----------------------------------------------------------------------
  1403.  *
  1404.  * NetUltraIOControl --
  1405.  *
  1406.  *    Handle ioctls for the Ultranet adapter..
  1407.  *
  1408.  * Results:
  1409.  *    SUCCESS if the ioctl was performed successfully, a standard
  1410.  *    Sprite error code otherwise.
  1411.  *
  1412.  * Side effects:
  1413.  *    Commands may be sent to the adapter and the adapter state
  1414.  *    may change.
  1415.  *
  1416.  *----------------------------------------------------------------------
  1417.  */
  1418.  
  1419. /*ARGSUSED*/
  1420. ReturnStatus
  1421. NetUltraIOControl(interPtr, ioctlPtr, replyPtr)
  1422.     Net_Interface *interPtr;    /* Interface on which to perform ioctl. */
  1423.     Fs_IOCParam *ioctlPtr;    /* Standard I/O Control parameter block */
  1424.     Fs_IOReply *replyPtr;    /* Size of outBuffer and returned signal */
  1425. {
  1426.     ReturnStatus status = SUCCESS;
  1427.     int    fmtStatus;
  1428.     int inSize;
  1429.     int outSize;
  1430.     NetUltraState    *statePtr = (NetUltraState *) interPtr->interfaceData;
  1431.  
  1432.     if (netUltraDebug) {
  1433.     printf("NetUltraIOControl: command = %d\n", ioctlPtr->command);
  1434.     }
  1435.     if ((ioctlPtr->command & ~0xffff) != IOC_ULTRA) {
  1436.     return DEV_INVALID_ARG;
  1437.     }
  1438.     switch(ioctlPtr->command) {
  1439.     case IOC_ULTRA_SET_FLAGS:
  1440.     case IOC_ULTRA_RESET_FLAGS:
  1441.     case IOC_ULTRA_GET_FLAGS:
  1442.         return GEN_NOT_IMPLEMENTED;
  1443.         break;
  1444.     case IOC_ULTRA_CLR:
  1445.     case IOC_ULTRA_INT:
  1446.     case IOC_ULTRA_WFI:
  1447.         return DEV_INVALID_ARG;
  1448.         break;
  1449.     case IOC_ULTRA_DUMP:
  1450.         return GEN_NOT_IMPLEMENTED;
  1451.         break;
  1452.     case IOC_ULTRA_DEBUG: {
  1453.         int    value;
  1454.         outSize = sizeof(int);
  1455.         inSize = ioctlPtr->inBufSize;
  1456.         fmtStatus = Fmt_Convert("w", ioctlPtr->format, &inSize,
  1457.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1458.                 (Address) &value);
  1459.         if (fmtStatus != 0) {
  1460.         printf("Format of IOC_ULTRA_DEBUG parameter failed, 0x%x\n",
  1461.             fmtStatus);
  1462.         return GEN_INVALID_ARG;
  1463.         }
  1464.         netUltraDebug = value;
  1465.         break;
  1466.     }
  1467.     case IOC_ULTRA_TRACE: {
  1468.         int    value;
  1469.         outSize = sizeof(int);
  1470.         inSize = ioctlPtr->inBufSize;
  1471.         fmtStatus = Fmt_Convert("w", ioctlPtr->format, &inSize,
  1472.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1473.                 (Address) &value);
  1474.         if (fmtStatus != 0) {
  1475.         printf("Format of IOC_ULTRA_TRACE parameter failed, 0x%x\n",
  1476.             fmtStatus);
  1477.         return GEN_INVALID_ARG;
  1478.         }
  1479.         netUltraTrace = value;
  1480.         break;
  1481.     }
  1482.     case IOC_ULTRA_RESET: 
  1483.         Net_UltraReset(interPtr);
  1484.         break;
  1485.     case IOC_ULTRA_HARD_RESET:
  1486.         Net_UltraHardReset(interPtr);
  1487.         break;
  1488.     case IOC_ULTRA_GET_ADAP_INFO: {
  1489.         NetUltraInfoCommand        cmd;
  1490.         Dev_UltraAdapterInfo    info;
  1491.  
  1492.         status = NetUltraInfo(statePtr, &cmd);
  1493.         if (status != SUCCESS) {
  1494.         return status;
  1495.         }
  1496.         info.version = cmd.version;
  1497.         info.error = cmd.error;
  1498.         info.hwModel = cmd.hwModel;
  1499.         info.hwVersion = cmd.hwVersion;
  1500.         info.hwRevision = cmd.hwRevision;
  1501.         info.hwOption = cmd.hwOption;
  1502.         info.hwSerial = cmd.hwSerial;
  1503.         inSize = sizeof(info);
  1504.         outSize = ioctlPtr->outBufSize;
  1505.         fmtStatus = Fmt_Convert("{w7}", mach_Format, &inSize,
  1506.         (Address) &info, ioctlPtr->format, &outSize,
  1507.         (Address) ioctlPtr->outBuffer);
  1508.         if (fmtStatus != 0) {
  1509.         if (fmtStatus == FMT_OUTPUT_TOO_SMALL) {
  1510.             return GEN_INVALID_ARG;
  1511.         } else {
  1512.             printf(
  1513.             "NetUltraIOControl: Fmt_Convert returned %d\n",
  1514.             fmtStatus);
  1515.             return FAILURE;
  1516.         }
  1517.         }
  1518.         break;
  1519.     }
  1520.     case IOC_ULTRA_DIAG: {
  1521.         NetUltraDiagCommand        cmd;
  1522.         Dev_UltraDiag        diag;
  1523.  
  1524.         status = NetUltraDiag(statePtr, &cmd);
  1525.         if (status != SUCCESS) {
  1526.         return status;
  1527.         }
  1528.         diag.version = cmd.version;
  1529.         diag.error = cmd.error;
  1530.         diag.hwModel = cmd.hwModel;
  1531.         diag.hwVersion = cmd.hwVersion;
  1532.         diag.hwRevision = cmd.hwRevision;
  1533.         diag.hwOption = cmd.hwOption;
  1534.         diag.hwSerial = cmd.hwSerial;
  1535.         inSize = sizeof(diag);
  1536.         outSize = ioctlPtr->outBufSize;
  1537.         fmtStatus = Fmt_Convert("{w7}", mach_Format, &inSize,
  1538.         (Address) &diag, ioctlPtr->format, &outSize,
  1539.         (Address) ioctlPtr->outBuffer);
  1540.         if (fmtStatus != 0) {
  1541.         if (fmtStatus == FMT_OUTPUT_TOO_SMALL) {
  1542.             return GEN_INVALID_ARG;
  1543.         } else {
  1544.             printf(
  1545.             "NetUltraIOControl: Fmt_Convert returned %d\n",
  1546.             fmtStatus);
  1547.             return FAILURE;
  1548.         }
  1549.         }
  1550.         break;
  1551.     }
  1552.     case IOC_ULTRA_EXTENDED_DIAG: {
  1553.         NetUltraExtDiagCommand    cmd;
  1554.         Dev_UltraExtendedDiag    extDiag;
  1555.         char            *buffer;
  1556.  
  1557.         buffer = (char *) malloc(NET_ULTRA_EXT_DIAG_BUF_SIZE);
  1558.         inSize = ioctlPtr->inBufSize;
  1559.         outSize = sizeof(extDiag);
  1560.         fmtStatus = Fmt_Convert("{w3}", ioctlPtr->format, &inSize,
  1561.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1562.                 (Address) &extDiag);
  1563.         if (fmtStatus != 0) {
  1564.         if (fmtStatus == FMT_INPUT_TOO_SMALL) {
  1565.             return GEN_INVALID_ARG;
  1566.         } else {
  1567.             printf("NetUltraIOControl: Fmt_Convert returned %d\n",
  1568.             fmtStatus);
  1569.             return FAILURE;
  1570.         }
  1571.         }
  1572.         status = NetUltraExtDiag(statePtr, extDiag.externalLoopback, 
  1573.                 buffer,&cmd);
  1574.         free(buffer);
  1575.         if (status != SUCCESS) {
  1576.         return status;
  1577.         }
  1578.         extDiag.version = cmd.version;
  1579.         extDiag.error = cmd.error;
  1580.         inSize = sizeof(extDiag);
  1581.         outSize = ioctlPtr->outBufSize;
  1582.         fmtStatus = Fmt_Convert("{w3}", mach_Format, &inSize,
  1583.         (Address) &extDiag, ioctlPtr->format, &outSize,
  1584.         (Address) ioctlPtr->outBuffer);
  1585.         if (fmtStatus != 0) {
  1586.         if (fmtStatus == FMT_OUTPUT_TOO_SMALL) {
  1587.             return GEN_INVALID_ARG;
  1588.         } else {
  1589.             printf(
  1590.             "NetUltraIOControl: Fmt_Convert returned %d\n",
  1591.             fmtStatus);
  1592.             return FAILURE;
  1593.         }
  1594.         }
  1595.         break;
  1596.     }
  1597.     case IOC_ULTRA_LOAD: {
  1598.         Dev_UltraLoad        load;
  1599.         Address            ucodePtr;
  1600.         inSize = 2 * sizeof(int);
  1601.         outSize = sizeof(load);
  1602.         fmtStatus = Fmt_Convert("w2", ioctlPtr->format, &inSize,
  1603.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1604.                 (Address) &load);
  1605.         if (fmtStatus != 0) {
  1606.         if (fmtStatus == FMT_INPUT_TOO_SMALL) {
  1607.             return GEN_INVALID_ARG;
  1608.         } else {
  1609.             printf("NetUltraIOControl: Fmt_Convert returned %d\n",
  1610.             fmtStatus);
  1611.             return FAILURE;
  1612.         }
  1613.         }
  1614.         /*
  1615.          * This assumes that there isn't any padding between the
  1616.          * two integers in NetUltraLoadCommand and the data buffer.
  1617.          */
  1618.         ucodePtr = (Address) ioctlPtr->inBuffer + inSize;
  1619.         status = NetUltraLoad(statePtr, load.address, load.length,
  1620.                 ucodePtr);
  1621.         break;
  1622.     }
  1623.     case IOC_ULTRA_GO: {
  1624.         Dev_UltraGo            go;
  1625.         inSize = ioctlPtr->inBufSize;
  1626.         outSize = sizeof(go);
  1627.         fmtStatus = Fmt_Convert("{w1}", ioctlPtr->format, &inSize,
  1628.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1629.                 (Address) &go.address);
  1630.         if (fmtStatus != 0) {
  1631.         if (fmtStatus == FMT_INPUT_TOO_SMALL) {
  1632.             return GEN_INVALID_ARG;
  1633.         } else {
  1634.             printf("NetUltraIOControl: Fmt_Convert returned %d\n",
  1635.             fmtStatus);
  1636.             return FAILURE;
  1637.         }
  1638.         }
  1639.         status = NetUltraGo(statePtr, go.address);
  1640.         break;
  1641.     }
  1642.     case IOC_ULTRA_INIT: {
  1643.         status = NetUltraInitAdapter(statePtr);
  1644.         break;
  1645.     }
  1646.     case IOC_ULTRA_START: {
  1647.         MASTER_LOCK(&interPtr->mutex);
  1648.         status = NetUltraStart(statePtr);
  1649.         MASTER_UNLOCK(&interPtr->mutex);
  1650.         break;
  1651.     }
  1652.     case IOC_ULTRA_ADDRESS: {
  1653.         /* 
  1654.          * Set the adapter address.  This is not the normal way to
  1655.          * do this (usually happens during route installation) but
  1656.          * it is useful for debugging. 
  1657.          */
  1658.         Net_UltraAddress    address;
  1659.         int            group;
  1660.         int            unit;
  1661.         inSize = ioctlPtr->inBufSize;
  1662.         outSize = sizeof(Net_UltraAddress);
  1663.         fmtStatus = Fmt_Convert("{b8}", ioctlPtr->format, &inSize,
  1664.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1665.                 (Address) &address);
  1666.         if (fmtStatus != 0) {
  1667.         if (fmtStatus == FMT_INPUT_TOO_SMALL) {
  1668.             return GEN_INVALID_ARG;
  1669.         } else {
  1670.             printf("NetUltraIOControl: Fmt_Convert returned %d\n",
  1671.             fmtStatus);
  1672.             return FAILURE;
  1673.         }
  1674.         }
  1675.         Net_UltraAddressGet(&address, &group, &unit);
  1676.         printf("Setting ultra address to %d/%d\n", group, unit); 
  1677.         MASTER_LOCK(&interPtr->mutex);
  1678.         status = Net_SetAddress(NET_ADDRESS_ULTRA,
  1679.             (Address) &address, 
  1680.             &interPtr->netAddress[NET_PROTO_RAW]);
  1681.         if (status != SUCCESS) {
  1682.         panic("NetUltraIOControl: Net_SetAddress failed\n");
  1683.         }
  1684.         MASTER_UNLOCK(&interPtr->mutex);
  1685.         break;
  1686.     }
  1687.     case IOC_ULTRA_SEND_DGRAM: {
  1688.         Dev_UltraSendDgram        dgram;
  1689.         inSize = ioctlPtr->inBufSize;
  1690.         outSize = sizeof(dgram);
  1691.         fmtStatus = Fmt_Convert("{w2{w2}wb*}", ioctlPtr->format, &inSize,
  1692.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1693.                 (Address) &dgram);
  1694.         if (fmtStatus != 0) {
  1695.         if (fmtStatus == FMT_INPUT_TOO_SMALL) {
  1696.             return GEN_INVALID_ARG;
  1697.         } else {
  1698.             printf("NetUltraIOControl: Fmt_Convert returned %d\n",
  1699.             fmtStatus);
  1700.             return FAILURE;
  1701.         }
  1702.         }
  1703.         status = NetUltraSendDgram(interPtr, &dgram.address, dgram.count,
  1704.             dgram.size, 
  1705.             (dgram.useBuffer == TRUE) ? (Address) dgram.buffer :
  1706.             (Address) NIL, &dgram.time);
  1707.         inSize = sizeof(dgram);
  1708.         outSize = ioctlPtr->outBufSize;
  1709.         fmtStatus = Fmt_Convert("{w2{w2}wb*}", mach_Format, &inSize,
  1710.         (Address) &dgram, ioctlPtr->format, &outSize,
  1711.         (Address) ioctlPtr->outBuffer);
  1712.         if (fmtStatus != 0) {
  1713.         if (fmtStatus == FMT_OUTPUT_TOO_SMALL) {
  1714.             return GEN_INVALID_ARG;
  1715.         } else {
  1716.             printf(
  1717.             "NetUltraIOControl: Fmt_Convert returned %d\n",
  1718.             fmtStatus);
  1719.             return FAILURE;
  1720.         }
  1721.         }
  1722.         break;
  1723.     }
  1724.     case IOC_ULTRA_ECHO: {
  1725.         Dev_UltraEcho        echo;
  1726.         inSize = ioctlPtr->inBufSize;
  1727.         outSize = sizeof(echo);
  1728.         fmtStatus = Fmt_Convert("{w}", ioctlPtr->format, &inSize,
  1729.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1730.                 (Address) &echo);
  1731.         if (fmtStatus != 0) {
  1732.         if (fmtStatus == FMT_INPUT_TOO_SMALL) {
  1733.             return GEN_INVALID_ARG;
  1734.         } else {
  1735.             printf("NetUltraIOControl: Fmt_Convert returned %d\n",
  1736.             fmtStatus);
  1737.             return FAILURE;
  1738.         }
  1739.         }
  1740.         if (echo.echo == TRUE) {
  1741.         statePtr->flags |= NET_ULTRA_STATE_ECHO;
  1742.         statePtr->flags &= ~NET_ULTRA_STATE_NORMAL;
  1743.         } else {
  1744.         statePtr->flags &= ~NET_ULTRA_STATE_ECHO;
  1745.         statePtr->flags |= NET_ULTRA_STATE_NORMAL;
  1746.         }
  1747.         break;
  1748.     }
  1749.     case IOC_ULTRA_SOURCE: {
  1750.         Dev_UltraSendDgram        dgram;
  1751.         inSize = ioctlPtr->inBufSize;
  1752.         outSize = sizeof(dgram);
  1753.         fmtStatus = Fmt_Convert("{w2{w2}wb*}", ioctlPtr->format, &inSize,
  1754.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1755.                 (Address) &dgram);
  1756.         if (fmtStatus != 0) {
  1757.         if (fmtStatus == FMT_INPUT_TOO_SMALL) {
  1758.             return GEN_INVALID_ARG;
  1759.         } else {
  1760.             printf("NetUltraIOControl: Fmt_Convert returned %d\n",
  1761.             fmtStatus);
  1762.             return FAILURE;
  1763.         }
  1764.         }
  1765.         status = NetUltraSource(interPtr, &dgram.address, dgram.count,
  1766.             dgram.size, 
  1767.             (dgram.useBuffer == TRUE) ? (Address) dgram.buffer :
  1768.             (Address) NIL, &dgram.time);
  1769.         inSize = sizeof(dgram);
  1770.         outSize = ioctlPtr->outBufSize;
  1771.         fmtStatus = Fmt_Convert("{w2{w2}wb*}", mach_Format, &inSize,
  1772.         (Address) &dgram, ioctlPtr->format, &outSize,
  1773.         (Address) ioctlPtr->outBuffer);
  1774.         if (fmtStatus != 0) {
  1775.         if (fmtStatus == FMT_OUTPUT_TOO_SMALL) {
  1776.             return GEN_INVALID_ARG;
  1777.         } else {
  1778.             printf(
  1779.             "NetUltraIOControl: Fmt_Convert returned %d\n",
  1780.             fmtStatus);
  1781.             return FAILURE;
  1782.         }
  1783.         }
  1784.         break;
  1785.     }
  1786.     case IOC_ULTRA_SINK: {
  1787.         Dev_UltraSink        sink;
  1788.         int                value;
  1789.         outSize = sizeof(int);
  1790.         inSize = ioctlPtr->inBufSize;
  1791.         fmtStatus = Fmt_Convert("w", ioctlPtr->format, &inSize,
  1792.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1793.                 (Address) &value);
  1794.         if (fmtStatus != 0) {
  1795.         printf("Format of IOC_ULTRA_TRACE parameter failed, 0x%x\n",
  1796.             fmtStatus);
  1797.         return GEN_INVALID_ARG;
  1798.         }
  1799.         outSize = ioctlPtr->outBufSize;
  1800.         sink.packets = packetsSunk;
  1801.         Timer_SubtractTicks(sinkEndTime, sinkStartTime, &sink.time);
  1802.         Timer_TicksToTime(sink.time, &sink.time);
  1803.         inSize = sizeof(sink);
  1804.         fmtStatus = Fmt_Convert("w{w2}", mach_Format, &inSize,
  1805.                 (Address) &sink, ioctlPtr->format, &outSize,
  1806.                 ioctlPtr->outBuffer);
  1807.         if (fmtStatus != 0) {
  1808.         printf("Format of IOC_ULTRA_TRACE parameter failed, 0x%x\n",
  1809.             fmtStatus);
  1810.         return GEN_INVALID_ARG;
  1811.         }
  1812.         if (value > 0) {
  1813.         statePtr->flags |= NET_ULTRA_STATE_SINK;
  1814.         statePtr->flags &= ~NET_ULTRA_STATE_NORMAL;
  1815.         packetsSunk = 0;
  1816.         } else {
  1817.         statePtr->flags &= ~NET_ULTRA_STATE_SINK;
  1818.         statePtr->flags |= NET_ULTRA_STATE_NORMAL;
  1819.         }
  1820.         break;
  1821.     }
  1822.     case IOC_ULTRA_COLLECT_STATS: {
  1823.         int        value;
  1824.         inSize = ioctlPtr->inBufSize;
  1825.         outSize = sizeof(int);
  1826.         fmtStatus = Fmt_Convert("w", ioctlPtr->format, &inSize,
  1827.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1828.                 (Address) &value);
  1829.         if (fmtStatus != 0) {
  1830.         if (fmtStatus == FMT_INPUT_TOO_SMALL) {
  1831.             return GEN_INVALID_ARG;
  1832.         } else {
  1833.             printf("NetUltraIOControl: Fmt_Convert returned %d\n",
  1834.             fmtStatus);
  1835.             return FAILURE;
  1836.         }
  1837.         }
  1838.         if (value == TRUE) {
  1839.         statePtr->flags |= NET_ULTRA_STATE_STATS;
  1840.         } else {
  1841.         statePtr->flags &= ~NET_ULTRA_STATE_STATS;
  1842.         }
  1843.         break;
  1844.     }
  1845.     case IOC_ULTRA_CLEAR_STATS: {
  1846.         bzero((char *) &statePtr->stats, sizeof(statePtr->stats));
  1847.         break;
  1848.     }
  1849.     case IOC_ULTRA_GET_STATS: {
  1850.         outSize = ioctlPtr->outBufSize;
  1851.         inSize = sizeof(Dev_UltraStats);
  1852.         fmtStatus = Fmt_Convert("w*", mach_Format, &inSize,
  1853.                 (Address) &statePtr->stats, 
  1854.                 ioctlPtr->format, &outSize,
  1855.                 ioctlPtr->outBuffer);
  1856.         if (fmtStatus != 0) {
  1857.         printf("Format of IOC_ULTRA_GET_STATS parameter failed, 0x%x\n",
  1858.             fmtStatus);
  1859.         return GEN_INVALID_ARG;
  1860.         }
  1861.         break;
  1862.     }
  1863.     case IOC_ULTRA_MAP_THRESHOLD: {
  1864.         int                value;
  1865.         outSize = sizeof(int);
  1866.         inSize = ioctlPtr->inBufSize;
  1867.         fmtStatus = Fmt_Convert("w", ioctlPtr->format, &inSize,
  1868.                 ioctlPtr->inBuffer, mach_Format, &outSize,
  1869.                 (Address) &value);
  1870.         if (fmtStatus != 0) {
  1871.         printf(
  1872.         "Format of IOC_ULTRA_MAP_THRESHOLD parameter failed, 0x%x\n",
  1873.             fmtStatus);
  1874.         return GEN_INVALID_ARG;
  1875.         }
  1876.         netUltraMapThreshold = value;
  1877.         break;
  1878.     }
  1879.     default: {
  1880.         printf("NetUltraIOControl: unknown ioctl 0x%x\n",
  1881.         ioctlPtr->command);
  1882.     }
  1883.  
  1884.     }
  1885.     return status;
  1886. }
  1887.  
  1888. /*
  1889.  *----------------------------------------------------------------------
  1890.  *
  1891.  * NetUltraSendReq --
  1892.  *
  1893.  *    Queue up a request for the adapter board. If there isn't
  1894.  *    any room in the queue then we block until there is.
  1895.  *
  1896.  * Results:
  1897.  *    Standard Sprite return status.
  1898.  *
  1899.  * Side effects:
  1900.  *    The adapter board is notified of the addition to the queue.
  1901.  *
  1902.  *----------------------------------------------------------------------
  1903.  */
  1904.  
  1905. ReturnStatus
  1906. NetUltraSendReq(statePtr, doneProc, data, rpc, scatterLength, scatterPtr, 
  1907.     requestSize, requestPtr)
  1908.     NetUltraState    *statePtr;    /* State of the adapter. */
  1909.     void        (*doneProc)();    /* Procedure to call when
  1910.                      * XRB is done. */
  1911.     ClientData        data;        /* Data used by doneProc. */
  1912.     Boolean        rpc;        /* Is this an RPC packet? */
  1913.     int            scatterLength;    /* Size of scatter/gather array. */
  1914.     Net_ScatterGather    *scatterPtr;    /* The scatter/gather array. */
  1915.     int            requestSize;    /* Size of the request. */
  1916.     NetUltraRequest    *requestPtr;    /* Request to be sent. */
  1917. {
  1918.     NetUltraXRB            *xrbPtr;
  1919.     NetUltraRequestHdr        *hdrPtr;
  1920.     NetUltraDMAInfo        *dmaPtr;
  1921.     ReturnStatus        status = SUCCESS;
  1922.     int                signal;
  1923.     NetUltraXRBInfo        *infoPtr;
  1924.     NetUltraTraceInfo        *tracePtr;
  1925.     int                size;
  1926.     int                i;
  1927.  
  1928.     if (netUltraDebug) {
  1929.     printf("NetUltraSendReq: sending a request\n");
  1930.     }
  1931.     xrbPtr = statePtr->nextToAdapterPtr;
  1932. #ifndef CLEAN
  1933.     if (netUltraTrace) {
  1934.     NEXT_TRACE(statePtr, &tracePtr);
  1935.     tracePtr->event = SEND_REQ;
  1936.     tracePtr->index = xrbPtr - statePtr->firstToAdapterPtr;
  1937.     Timer_GetCurrentTicks(&tracePtr->ticks);
  1938.     }
  1939. #endif
  1940.     if (statePtr->nextToAdapterPtr->filled) {
  1941. #ifndef CLEAN
  1942.     if (netUltraTrace) {
  1943.         NEXT_TRACE(statePtr, &tracePtr);
  1944.         tracePtr->event = TO_ADAPTER_FILLED;
  1945.         tracePtr->index = statePtr->nextToAdapterPtr - 
  1946.         statePtr->firstToAdapterPtr;
  1947.     }
  1948. #endif
  1949.     do {
  1950.         if (netUltraDebug) {
  1951.         printf("NetUltraSendReq: no XRB free, waiting\n");
  1952.         }
  1953.         statePtr->toAdapterAvail.waiting = TRUE;
  1954.         signal = Sync_SlowMasterWait(
  1955.             (unsigned int) &statePtr->toAdapterAvail,
  1956.             &statePtr->interPtr->mutex, TRUE);
  1957.         if (signal) {
  1958.         return GEN_ABORTED_BY_SIGNAL;
  1959.         }
  1960.     } while(statePtr->nextToAdapterPtr->filled);
  1961.     }
  1962.     xrbPtr = statePtr->nextToAdapterPtr;
  1963.     hdrPtr = (NetUltraRequestHdr *) requestPtr;
  1964.     infoPtr = (NetUltraXRBInfo *) List_First(statePtr->freeXRBInfoList);
  1965.     if ((List_Links *) infoPtr == statePtr->freeXRBInfoList) {
  1966.     panic("NetUltraSendReq: no available XRBInfo structures!");
  1967.     }
  1968.     List_Remove((List_Links *) infoPtr);
  1969.     List_Insert((List_Links *) infoPtr, 
  1970.     LIST_ATFRONT(statePtr->pendingXRBInfoList));
  1971.     infoPtr->doneProc = doneProc;
  1972.     infoPtr->doneData = data;
  1973.     infoPtr->xrbPtr = xrbPtr;
  1974.     infoPtr->scatterPtr = scatterPtr;
  1975.     infoPtr->scatterLength = scatterLength;
  1976.     infoPtr->requestSize = requestSize;
  1977.     infoPtr->requestPtr = (union NetUltraRequest *) requestPtr;
  1978.     infoPtr->flags = NET_ULTRA_INFO_PENDING;
  1979. #ifndef CLEAN
  1980.     if (netUltraDebug) {
  1981.     printf("NetUltraSendReq: using 0x%x\n", infoPtr);
  1982.     }
  1983. #endif
  1984. #ifndef CLEAN
  1985.     if (netUltraTrace) {
  1986.     NEXT_TRACE(statePtr, &tracePtr);
  1987.     tracePtr->event = SEND_REQ_INFO;
  1988.     tracePtr->index = xrbPtr - statePtr->firstToAdapterPtr;
  1989.     tracePtr->infoPtr = infoPtr;
  1990.     }
  1991. #endif
  1992.     hdrPtr->infoPtr = infoPtr;
  1993.     hdrPtr->status = 0;
  1994.     hdrPtr->reference = 0;
  1995.     if (scatterLength > 0) {
  1996.     Address        buffer;
  1997.     List_Links    *itemPtr;
  1998.     /*
  1999.      * If the buffer is not in DVMA space then get one that is.
  2000.      */
  2001.     if (! DVMA_ADDRESS(scatterPtr[0].bufAddr, statePtr)) {
  2002.         if (netUltraDebug) {
  2003.         printf("Data is not in DVMA space.\n");
  2004.         }
  2005.         while(List_IsEmpty(statePtr->freeBufferList)) {
  2006.         int        signal;
  2007.         statePtr->bufferAvail.waiting = TRUE;
  2008.         signal = Sync_SlowMasterWait(
  2009.             (unsigned int) &statePtr->bufferAvail,
  2010.             &statePtr->interPtr->mutex, TRUE);
  2011.         if (signal) {
  2012.             status = GEN_ABORTED_BY_SIGNAL;
  2013.             goto exit;
  2014.         }
  2015.         }
  2016.         itemPtr = List_First(statePtr->freeBufferList);
  2017.         if (itemPtr == statePtr->freeBufferList) {
  2018.         panic("NetUltraOutput: list screwup\n");
  2019.         }
  2020.         List_Remove(itemPtr);
  2021.         buffer = (Address) itemPtr;
  2022.         infoPtr->flags |= NET_ULTRA_INFO_STD_BUFFER;
  2023.         if (rpc) {
  2024.         int    lastIndex;
  2025.         /*
  2026.          * This is a standard RPC packet with 4 parts --
  2027.          * packet header, RPC header, RPC params, and data. 
  2028.          */
  2029.         size = 0;
  2030.         lastIndex = scatterLength - 1;
  2031.         for (i = 0; i < scatterLength; i++) {
  2032.             size += scatterPtr[i].length;
  2033.         }
  2034.         Net_GatherCopy(scatterPtr, scatterLength, buffer);
  2035.         } else {
  2036.  
  2037.         if (netUltraDebug) {
  2038.             printf("Copying data into DVMA space.\n");
  2039.         }
  2040.         Net_GatherCopy(scatterPtr, 1, buffer);
  2041.         size = scatterPtr[0].length;
  2042.         }
  2043.     } else {
  2044.         /* 
  2045.          * The data is already in DVMA space.  It had better be contiguous!
  2046.          */
  2047.         if (netUltraDebug) {
  2048.         printf("Data is already in DVMA space.\n");
  2049.         }
  2050.         buffer = scatterPtr[0].bufAddr;
  2051.         size = scatterPtr[0].length;
  2052.     }
  2053.     if (! DVMA_ADDRESS(buffer, statePtr)) {
  2054.         buffer = BUFFER_TO_DVMA(buffer, statePtr);
  2055.     }
  2056.     hdrPtr->buffer = DVMA_TO_VME(buffer, statePtr);
  2057.     hdrPtr->size = size;
  2058.     } else {
  2059.     hdrPtr->size = 0;
  2060.     }
  2061.     if (netUltraDebug) {
  2062.     printf("NetUltraSendReq: hdrPtr->buffer = 0x%x, size = %d\n",
  2063.         hdrPtr->buffer, hdrPtr->size);
  2064.     }
  2065. #ifndef CLEAN
  2066.     if (statePtr->flags & NET_ULTRA_STATE_STATS) {
  2067.     if (hdrPtr->cmd == NET_ULTRA_DGRAM_SEND_REQ) {
  2068.         statePtr->stats.packetsSent++;
  2069.         statePtr->stats.bytesSent += hdrPtr->size;
  2070.         statePtr->stats.sentHistogram[hdrPtr->size >> 10]++;
  2071.     }
  2072.     }
  2073. #endif
  2074.     bcopy((char *) requestPtr, (char *) &xrbPtr->request, requestSize);
  2075.     dmaPtr = &xrbPtr->dma;
  2076.     if (hdrPtr->cmd == NET_ULTRA_DGRAM_SEND_REQ) {
  2077.     dmaPtr->cmd = NET_ULTRA_DMA_CMD_XRB_DATA;
  2078.     statePtr->numWritePending++;
  2079. #ifndef CLEAN
  2080.     if (netUltraDebug) {
  2081.         printf("NetUltraSendReq: number of pending writes = %d.\n",
  2082.         statePtr->numWritePending);
  2083.     }
  2084. #endif
  2085.     if (statePtr->numWritePending > statePtr->maxWritePending) {
  2086.         panic("NetUltraSendReq: too many writes.\n");
  2087.     }
  2088.     } else if (hdrPtr->cmd == NET_ULTRA_DGRAM_RECV_REQ) {
  2089.     dmaPtr->cmd = NET_ULTRA_DMA_CMD_XRB;
  2090.     statePtr->numReadPending++;
  2091. #ifndef CLEAN
  2092.     if (netUltraDebug) {
  2093.         printf("NetUltraSendReq: number of pending reads = %d.\n",
  2094.         statePtr->numReadPending);
  2095.     }
  2096. #endif
  2097.     if (statePtr->numReadPending > statePtr->maxReadPending) {
  2098.         panic("NetUltraSendReq: too many reads.\n");
  2099.     }
  2100.     } else {
  2101.     dmaPtr->cmd = NET_ULTRA_DMA_CMD_XRB;
  2102.     }
  2103.     dmaPtr->id = 0;
  2104.     dmaPtr->reference = 0;
  2105.     dmaPtr->offset = 0;
  2106.     dmaPtr->infoPtr = (NetUltraXRBInfo *) NIL;
  2107.     dmaPtr->length = requestSize;
  2108.     /*
  2109.      * Set the filled field so the adapter will process the XRB.
  2110.      */
  2111.     if (netUltraDebug) {
  2112.     printf("NetUltraSendReq: xrbPtr = 0x%x\n", xrbPtr);
  2113.     }
  2114.     xrbPtr->filled = 1;
  2115.     if (statePtr->nextToAdapterPtr == statePtr->lastToAdapterPtr) {
  2116.     statePtr->nextToAdapterPtr = statePtr->firstToAdapterPtr;
  2117.     } else {
  2118.     statePtr->nextToAdapterPtr++;
  2119.     }
  2120.     /*
  2121.      * Poke the adapter by setting the address register to 0. This
  2122.      * tells it to look in the queue.
  2123.      */
  2124.     *statePtr->intrReg = 0;
  2125. #ifndef CLEAN
  2126.     if (netUltraDebug) {
  2127.     printf("NetUltraSendReq: returning\n");
  2128.     }
  2129. #endif
  2130. exit:
  2131.     return status;
  2132. }
  2133.  
  2134. /*
  2135.  *----------------------------------------------------------------------
  2136.  *
  2137.  * GetStatusString --
  2138.  *
  2139.  *    Returns a string corresponding to the given status (status
  2140.  *    is a field in a NetUltraRequestHdr.
  2141.  *
  2142.  * Results:
  2143.  *    Ptr to string describing the status.
  2144.  *
  2145.  * Side effects:
  2146.  *    None.
  2147.  *
  2148.  *----------------------------------------------------------------------
  2149.  */
  2150.  
  2151. static char *
  2152. GetStatusString(status)
  2153.     unsigned char    status;
  2154. {
  2155.     static char *statusMsg[] = {
  2156.     "Unknown",                /* 0 */
  2157.     "OK",                    /* 1 */
  2158.     "FAIL: invalid request",        /* 2 */
  2159.     "OK: EOM",                /* 3 */
  2160.     "FAIL: no resources",            /* 4 */
  2161.     "OK: decide",                /* 5 */
  2162.     "FAIL: unknown reference",        /* 6 */
  2163.     "OK: closed",                /* 7 */
  2164.     "FAIL: buffer too small",        /* 8 */
  2165.     "OK; withdrawn",            /* 9 */
  2166.     "FAIL: buffer too large",        /* 10 */
  2167.     "OK: reject connection",        /* 11 */
  2168.     "FAIL: illegal request",        /* 12 */
  2169.     "OK: connection request",        /* 13 */
  2170.     "FAIL: REM abort",            /* 14 */
  2171.     "OK: closing",                /* 15 */
  2172.     "FAIL: LOC timeout",            /* 16 */
  2173.     "OK: timed-out",            /* 17 */
  2174.     "FAIL: unknown connection class",     /* 18 */
  2175.     "OK: out of sequence",            /* 19 */
  2176.     "FAIL: duplicate request",        /* 20 */
  2177.     "Unknown",                /* 21 */
  2178.     "FAIL: connection rejected",        /* 22 */
  2179.     "Unknown",                /* 23 */
  2180.     "FAIL: negotiation failed",        /* 24 */
  2181.     "Unknown",                /* 25 */
  2182.     "FAIL: illegal address",        /* 26 */
  2183.     "Unknown",                /* 27 */
  2184.     "FAIL: network error",            /* 28 */
  2185.     "Unknown",                /* 29 */
  2186.     "FAIL: protocol error",            /* 30 */
  2187.     "Unknown",                /* 31 */
  2188.     "FAIL: illegal RB length",        /* 32 */
  2189.     "Unknown",                /* 33 */
  2190.     "FAIL: unknown SAP id",            /* 34 */
  2191.     "Unknown",                /* 35 */
  2192.     "FAIL: zero RB id",            /* 36 */
  2193.     "Unknown",                /* 37 */
  2194.     "FAIL: adapter down",            /* 38 */
  2195.     };
  2196.     static int numStatusMsg = sizeof(statusMsg) / sizeof(char *);
  2197.  
  2198.     if (status >= numStatusMsg) {
  2199.     return "Unknown";
  2200.     } else {
  2201.     return statusMsg[status];
  2202.     }
  2203. }
  2204.  
  2205. /*
  2206.  *----------------------------------------------------------------------
  2207.  *
  2208.  * InitQueues --
  2209.  *
  2210.  *    Initializes the XRB queues.
  2211.  *
  2212.  * Results:
  2213.  *    None.
  2214.  *
  2215.  * Side effects:
  2216.  *    Memory is allocated and mapped into DMA space if necessary.
  2217.  *
  2218.  *----------------------------------------------------------------------
  2219.  */
  2220.  
  2221. static void
  2222. InitQueues(statePtr)
  2223.     NetUltraState    *statePtr;    /* State of the adapter. */
  2224. {
  2225.     int        size;
  2226.     Address    addr;
  2227.     List_Links    *itemPtr;
  2228.     int        i;
  2229.  
  2230.     if (!(statePtr->queuesInit)) {
  2231.     /*
  2232.      * Allocate XRBs that go from the adapter to the host. 
  2233.      */
  2234.     size = sizeof(NetUltraXRB) * NET_ULTRA_NUM_TO_HOST;
  2235.     addr = (Address) malloc(size);
  2236.     addr = VmMach_DMAAlloc(size, (Address) addr);
  2237.     if (addr == (Address) NIL) {
  2238.         panic("NetUltraInit: unable to allocate DMA space.\n");
  2239.     }
  2240.     statePtr->firstToHostPtr = (NetUltraXRB *) addr;
  2241.     /* 
  2242.      * Allocate XRBs that go from the host to the adapter. 
  2243.      */
  2244.     size = sizeof(NetUltraXRB) * NET_ULTRA_NUM_TO_ADAPTER;
  2245.     addr = (Address) malloc(size);
  2246.     addr = VmMach_DMAAlloc(size, (Address) addr);
  2247.     if (addr == (Address) NIL) {
  2248.         panic("NetUltraInit: unable to allocate DMA space.\n");
  2249.     }
  2250.     statePtr->firstToAdapterPtr = (NetUltraXRB *) addr;
  2251.     statePtr->pendingXRBInfoList = &statePtr->pendingXRBInfoListHdr;
  2252.     statePtr->freeXRBInfoList = &statePtr->freeXRBInfoListHdr;
  2253.     List_Init(statePtr->pendingXRBInfoList);
  2254.     List_Init(statePtr->freeXRBInfoList);
  2255.     for (i = 0; i < NET_ULTRA_NUM_TO_ADAPTER + NET_ULTRA_NUM_TO_HOST; i++) {
  2256.         itemPtr = (List_Links *) malloc(sizeof(NetUltraXRBInfo));
  2257.         List_InitElement(itemPtr);
  2258.         List_Insert(itemPtr, LIST_ATREAR(statePtr->freeXRBInfoList));
  2259.     }
  2260.     /*
  2261.      * Allocate buffers in DVMA space for pending reads and writes. 
  2262.      */
  2263.     statePtr->maxReadPending = NET_ULTRA_PENDING_READS;
  2264.     statePtr->numReadPending = 0;
  2265.     statePtr->maxWritePending = NET_ULTRA_PENDING_WRITES;
  2266.     statePtr->numWritePending = 0;
  2267.     statePtr->numBuffers = statePtr->maxReadPending + 
  2268.         statePtr->maxWritePending;
  2269.     statePtr->bufferSize = NET_ULTRA_MAX_BYTES;
  2270.     size = statePtr->numBuffers * statePtr->bufferSize;
  2271.     addr = (Address) malloc(size);
  2272.     statePtr->buffers = addr;
  2273.     addr = VmMach_DMAAlloc(size, (Address) addr);
  2274.     statePtr->buffersDVMA = addr;
  2275.     statePtr->freeBufferList = &statePtr->freeBufferListHdr;
  2276.  
  2277.     statePtr->queuesInit = TRUE;
  2278.     }
  2279.     statePtr->lastToHostPtr = statePtr->firstToHostPtr + 
  2280.         NET_ULTRA_NUM_TO_HOST - 1;
  2281.     statePtr->nextToHostPtr = statePtr->firstToHostPtr;
  2282.     statePtr->lastToAdapterPtr = statePtr->firstToAdapterPtr + 
  2283.         NET_ULTRA_NUM_TO_ADAPTER - 1;
  2284.     statePtr->nextToAdapterPtr = statePtr->firstToAdapterPtr;
  2285.     size = sizeof(NetUltraXRB) * NET_ULTRA_NUM_TO_HOST;
  2286.     bzero((char *) statePtr->firstToHostPtr, size);
  2287.     size = sizeof(NetUltraXRB) * NET_ULTRA_NUM_TO_ADAPTER;
  2288.     bzero((char *) statePtr->firstToAdapterPtr, size);
  2289.     while (!List_IsEmpty(statePtr->pendingXRBInfoList)) {
  2290.     itemPtr = List_First(statePtr->pendingXRBInfoList);
  2291.     List_Remove(itemPtr);
  2292.     List_Insert(itemPtr, LIST_ATREAR(statePtr->freeXRBInfoList));
  2293.     }
  2294.     bzero((char *) statePtr->buffers, statePtr->numBuffers * 
  2295.     statePtr->bufferSize);
  2296.     List_Init(statePtr->freeBufferList);
  2297.     for (i = 0; i < statePtr->numBuffers; i++) {
  2298.     itemPtr = (List_Links *) 
  2299.         (statePtr->buffers + (i * statePtr->bufferSize));
  2300.     List_InitElement(itemPtr);
  2301.     List_Insert(itemPtr, LIST_ATREAR(statePtr->freeBufferList));
  2302.     }
  2303. }
  2304.  
  2305. /*
  2306.  *----------------------------------------------------------------------
  2307.  *
  2308.  * NetUltraPendingRead --
  2309.  *
  2310.  *    Send a pending read to the adapter.
  2311.  *
  2312.  * Results:
  2313.  *    Standard Sprite return status.
  2314.  *
  2315.  * Side effects:
  2316.  *    A "read datagram" XRB is sent to the adapter.
  2317.  *
  2318.  *----------------------------------------------------------------------
  2319.  */
  2320.  
  2321. ReturnStatus
  2322. NetUltraPendingRead(interPtr, size, buffer)
  2323.     Net_Interface    *interPtr;    /* Interface to read from. */
  2324.     int            size;        /* Size of the data buffer. */
  2325.     Address        buffer;        /* Address of the buffer in DMA space */
  2326. {
  2327.     NetUltraState        *statePtr;
  2328.     NetUltraRequest        request;
  2329.     NetUltraDatagramRequest    *dgramReqPtr;
  2330.     NetUltraRequestHdr        *hdrPtr;
  2331.     ReturnStatus        status = SUCCESS;
  2332.     Net_ScatterGather        scatter;
  2333.  
  2334.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2335.     if (!(statePtr->flags & NET_ULTRA_STATE_START)) {
  2336.     printf("NetUltraPendingRead: adapter not started!\n");
  2337.     return FAILURE;
  2338.     }
  2339. #ifndef CLEAN
  2340.     if (netUltraDebug) {
  2341.     printf("NetUltraPendingRead: queuing a pending read.\n");
  2342.     printf("Buffer size = %d, buffer = 0x%x\n", size, buffer);
  2343.     }
  2344. #endif
  2345.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2346.     bzero((char *) &request, sizeof(request));
  2347.     dgramReqPtr = &request.dgram;
  2348.     hdrPtr = &dgramReqPtr->hdr;
  2349.     dgramReqPtr->remoteAddress = wildcardAddress;
  2350.     dgramReqPtr->localAddress = wildcardAddress;
  2351.     hdrPtr->cmd = NET_ULTRA_DGRAM_RECV_REQ;
  2352.     /*
  2353.      * Save room at the beginning of the buffer for the datagram request
  2354.      * block.  The higher-level software expects the packet header to
  2355.      * proceed the packet (this should be fixed sometime).
  2356.      */
  2357.     buffer += sizeof(NetUltraDatagramRequest);
  2358.     size -= sizeof(NetUltraDatagramRequest);
  2359.     scatter.bufAddr = buffer;
  2360.     scatter.length = size;
  2361.     status = NetUltraSendReq(statePtr, ReadDone, (ClientData) 0, FALSE,  
  2362.     1, &scatter, sizeof(NetUltraDatagramRequest), &request);
  2363.     if (status != SUCCESS) {
  2364.     printf("NetUltraPendingRead: could not send request to adapter\n");
  2365.     }
  2366. #ifndef CLEAN
  2367.     if (netUltraDebug) {
  2368.     printf("NetUltraPendingRead: returning.\n");
  2369.     }
  2370. #endif
  2371.     return status;
  2372. }
  2373.  
  2374. /*
  2375.  *----------------------------------------------------------------------
  2376.  *
  2377.  * ReadDone --
  2378.  *
  2379.  *    This routine is called from the interrupt handler when a read
  2380.  *    request completes.
  2381.  *
  2382.  * Results:
  2383.  *    None.
  2384.  *
  2385.  * Side effects:
  2386.  *    None.
  2387.  *
  2388.  *----------------------------------------------------------------------
  2389.  */
  2390.  
  2391. static void
  2392. ReadDone(interPtr, infoPtr)
  2393.     Net_Interface    *interPtr;    /* Interface. */
  2394.     NetUltraXRBInfo    *infoPtr;    /* Info about XRB that completed. */
  2395. {
  2396.     NetUltraXRB            *xrbPtr;
  2397.     NetUltraDatagramRequest    *reqPtr;
  2398.     NetUltraRequestHdr        *hdrPtr;
  2399.     NetUltraState        *statePtr;
  2400.     int                size;
  2401.     Address            buffer = (Address) NIL;
  2402.     ReturnStatus        status = SUCCESS;
  2403.  
  2404.     xrbPtr = infoPtr->xrbPtr;
  2405.     reqPtr = &xrbPtr->request.dgram;
  2406.     hdrPtr = &reqPtr->hdr;
  2407.  
  2408.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2409.     if (!(hdrPtr->status & NET_ULTRA_STATUS_OK)) {
  2410.     panic("ReadDone: read failed 0x%x (continuable)\n", hdrPtr->status);
  2411.     } else {
  2412. #ifndef CLEAN
  2413.     if (netUltraDebug) {
  2414.         char    local[32];
  2415.         char    remote[32];
  2416.         printf("ReadDone: received a packet.\n");
  2417.         *local = '\0';
  2418.         *remote = '\0';
  2419.         (void) Net_UltraAddrToString(&reqPtr->localAddress.address, 
  2420.             local);
  2421.         (void) Net_UltraAddrToString(&reqPtr->remoteAddress.address, 
  2422.             remote);
  2423.         printf("Local address: %s\n", local);
  2424.         printf("Remote address: %s\n", remote);
  2425.         printf("Data size = %d\n", hdrPtr->size);
  2426.         if (hdrPtr->size > 0) {
  2427.         printf("Data: %s\n", hdrPtr->buffer + VMMACH_DMA_START_ADDR);
  2428.         }
  2429.     }
  2430. #endif
  2431.     /*
  2432.      * Adjust size and start of buffer to account for the space
  2433.      * for the request block.
  2434.      */
  2435.     buffer = VME_TO_BUFFER(hdrPtr->buffer, statePtr) -
  2436.             sizeof(NetUltraDatagramRequest);
  2437.     size = hdrPtr->size + sizeof(NetUltraDatagramRequest);
  2438.     if (statePtr->flags & NET_ULTRA_STATE_NORMAL) {
  2439.         /* 
  2440.          * Copy the request block (packet header) to the start of the
  2441.          * packet. 
  2442.          */
  2443.  
  2444.         *((NetUltraDatagramRequest *) buffer) = *reqPtr;
  2445.         /*
  2446.          * Release the lock around interface so that the RPC system
  2447.          * can output a packet in response to this one.  The XRB is
  2448.          * still marked as filled, so the adapter won't overwrite it.
  2449.          * Also the XRBinfo is not marked as pending, so the interrupt
  2450.          * routine won't re-process the packet should it loop around
  2451.          * the queue before Net_Input returns.
  2452.          */
  2453.         MASTER_UNLOCK(&interPtr->mutex);
  2454.         Net_Input(interPtr, buffer, size);
  2455.         MASTER_LOCK(&interPtr->mutex);
  2456.     } else if (statePtr->flags & NET_ULTRA_STATE_ECHO) {
  2457.         Net_ScatterGather        tmpScatter;
  2458.         if (netUltraDebug) {
  2459.         printf("ReadDone: returning datagram to sender.\n");
  2460.         }
  2461.         hdrPtr->cmd = NET_ULTRA_DGRAM_SEND_REQ;
  2462.         hdrPtr->status = 0;
  2463.         tmpScatter.bufAddr = BUFFER_TO_DVMA(buffer, statePtr);
  2464.         tmpScatter.length = hdrPtr->size;
  2465.         status = NetUltraSendReq(statePtr, EchoDone, (ClientData) NIL, 
  2466.             FALSE, 1, &tmpScatter,sizeof(NetUltraDatagramRequest),
  2467.             (NetUltraRequest *) reqPtr);
  2468.         if (status != SUCCESS) {
  2469.         panic("ReadDone: unable to return datagram to sender.\n");
  2470.         }
  2471.     } else if (statePtr->flags & NET_ULTRA_STATE_DSND_TEST) {
  2472.         Net_ScatterGather        tmpScatter;
  2473.         dsndCount--;
  2474.         if (dsndCount > 0) {
  2475.         if (netUltraDebug) {
  2476.             printf("ReadDone: returning datagram to sender.\n");
  2477.         }
  2478.         hdrPtr->cmd = NET_ULTRA_DGRAM_SEND_REQ;
  2479.         hdrPtr->status = 0;
  2480.         tmpScatter.bufAddr = BUFFER_TO_DVMA(buffer, statePtr);
  2481.         tmpScatter.length = hdrPtr->size;
  2482.         status = NetUltraSendReq(statePtr, EchoDone, (ClientData) NIL, 
  2483.                 FALSE, 1, &tmpScatter,
  2484.                 sizeof(NetUltraDatagramRequest),
  2485.                 (NetUltraRequest *) reqPtr);
  2486.         if (status != SUCCESS) {
  2487.             panic("ReadDone: unable to return datagram to sender.\n");
  2488.         }
  2489.         } else {
  2490.  
  2491.         /*
  2492.          * Notify the waiting process that the last datagram has
  2493.          * arrived.
  2494.          */
  2495.         Sync_Broadcast(&dsndTestDone);
  2496.         }
  2497.     } else if (statePtr->flags & NET_ULTRA_STATE_SINK) {
  2498.         packetsSunk++;
  2499.     }
  2500.     }
  2501.     statePtr->numReadPending--;
  2502.     if (statePtr->numReadPending < 0) {
  2503.     panic("ReadDone: number of pending reads < 0.\n");
  2504.     }
  2505.     /* 
  2506.      * This may introduce a deadlock if the queues are of size 1, 
  2507.      * since the XRB and info structures are
  2508.      * not freed until this routine (ReadDone) returns, and 
  2509.      * NetUltraPendingRead needs to use these structures.  If the queues
  2510.      * are greater than 1 then NetUltraPendingRead may have to
  2511.      * wait for an XRB to free up, but that should be ok.
  2512.      */
  2513.     status = NetUltraPendingRead(interPtr, statePtr->bufferSize, 
  2514.         BUFFER_TO_DVMA(buffer,statePtr));
  2515.     if (status != SUCCESS) {
  2516.     printf("ReadDone: could not queue next pending read.\n");
  2517.     }
  2518. #ifndef CLEAN
  2519.     if (netUltraDebug) {
  2520.     printf("ReadDone: returning.\n");
  2521.     }
  2522. #endif
  2523. }
  2524.  
  2525. /*
  2526.  *----------------------------------------------------------------------
  2527.  *
  2528.  * EchoDone --
  2529.  *
  2530.  *    This routine is called when the write of a datagram that is
  2531.  *    being echoed back to the sender completes.  All it does is
  2532.  *    decrement the number of pending writes.
  2533.  *
  2534.  * Results:
  2535.  *    None.
  2536.  *
  2537.  * Side effects:
  2538.  *    None.
  2539.  *
  2540.  *----------------------------------------------------------------------
  2541.  */
  2542.  
  2543. /*ARGSUSED*/
  2544. static void
  2545. EchoDone(interPtr, infoPtr)
  2546.     Net_Interface    *interPtr;    /* Interface. */
  2547.     NetUltraXRBInfo    *infoPtr;    /* Info about XRB that completed. */
  2548. {
  2549.     NetUltraState    *statePtr;
  2550.  
  2551.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2552.     statePtr->numWritePending--;
  2553. }
  2554.  
  2555.  
  2556. /*
  2557.  *----------------------------------------------------------------------
  2558.  *
  2559.  * NetUltraSendDgram --
  2560.  *
  2561.  *    This routine will send a datagram to the specified host.  It
  2562.  *    is intended for debugging purposes.  
  2563.  *
  2564.  * Results:
  2565.  *    None.
  2566.  *
  2567.  * Side effects:
  2568.  *    A write is queued to the adapter.
  2569.  *
  2570.  *----------------------------------------------------------------------
  2571.  */
  2572.  
  2573. static ReturnStatus
  2574. NetUltraSendDgram(interPtr, netAddressPtr, count, bufSize, buffer, timePtr)
  2575.     Net_Interface    *interPtr;        /* Interface to send on. */
  2576.     Net_Address        *netAddressPtr;        /* Host to send to. */
  2577.     int            count;            /* Number of times to send
  2578.                          * datagram. */
  2579.     int            bufSize;        /* Size of data buffer. */
  2580.     Address        buffer;            /* Data to send. */
  2581.     Time        *timePtr;        /* Place to store total 
  2582.                          * time to send datagrams. */
  2583. {
  2584.     NetUltraState        *statePtr;
  2585.     NetUltraRequest        request;
  2586.     NetUltraDatagramRequest    *dgramReqPtr;
  2587.     NetUltraRequestHdr        *hdrPtr;
  2588.     ReturnStatus        status;
  2589.     Timer_Ticks         startTime;
  2590.     Timer_Ticks         endTime;
  2591.     Timer_Ticks         curTime;
  2592.     NetUltraTraceInfo        *tracePtr;
  2593.     Net_ScatterGather        scatter;
  2594.     char            *ptr;
  2595.  
  2596.     MASTER_LOCK(&interPtr->mutex);
  2597. #ifndef CLEAN
  2598.     if (netUltraDebug) {
  2599.     char    address[100];
  2600.     (void) Net_AddrToString(netAddressPtr,  address);
  2601.     printf("NetUltraSendDgram: sending to %s\n", address);
  2602.     }
  2603. #endif
  2604.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2605.     if (!(statePtr->flags & NET_ULTRA_STATE_START)) {
  2606.     printf("NetUltraSendDgram: adapter not started!\n");
  2607.     status = FAILURE;
  2608.     goto exit;
  2609.     }
  2610.     bzero((char *) &request, sizeof(request));
  2611.     dgramReqPtr = &request.dgram;
  2612.     hdrPtr = &dgramReqPtr->hdr;
  2613.     dgramReqPtr->remoteAddress = wildcardAddress;
  2614.     dgramReqPtr->remoteAddress.tsapSize = 2;
  2615.     dgramReqPtr->remoteAddress.tsap[1] = 1;
  2616.     dgramReqPtr->remoteAddress.address = netAddressPtr->address.ultra;
  2617.     ptr = (char *) &dgramReqPtr->remoteAddress.address;
  2618.     ptr[1] = 0x49;
  2619.     ptr[6] = 0xfe;
  2620.     dgramReqPtr->localAddress = wildcardAddress;
  2621.     dgramReqPtr->localAddress.tsapSize = 2;
  2622.     dgramReqPtr->localAddress.tsap[1] = 1;
  2623.     dgramReqPtr->localAddress.address = 
  2624.     interPtr->netAddress[NET_PROTO_RAW].address.ultra;
  2625.     ptr = (char *) &dgramReqPtr->localAddress.address;
  2626.     ptr[1] = 0x49;
  2627.     ptr[6] = 0xfe;
  2628.     hdrPtr->cmd = NET_ULTRA_DGRAM_SEND_REQ;
  2629.     scatter.bufAddr = buffer;
  2630.     scatter.length = bufSize;
  2631.     statePtr->flags |= NET_ULTRA_STATE_DSND_TEST;
  2632.     statePtr->flags &= ~NET_ULTRA_STATE_NORMAL;
  2633.     dsndCount = count;
  2634. #ifndef CLEAN
  2635.     if (netUltraTrace) {
  2636.     NEXT_TRACE(statePtr, &tracePtr);
  2637.     tracePtr->event = DSND;
  2638.     Timer_GetCurrentTicks(&curTime);
  2639.     tracePtr->ticks = curTime;
  2640.     }
  2641. #endif
  2642.     Timer_GetCurrentTicks(&startTime);
  2643.     status = NetUltraSendReq(statePtr, DgramSendDone, (ClientData) NIL,
  2644.         FALSE, 1, &scatter, sizeof(NetUltraDatagramRequest), &request);
  2645.     Sync_MasterWait(&(dsndTestDone), &(interPtr->mutex), FALSE);
  2646.     Timer_GetCurrentTicks(&endTime);
  2647. #ifndef CLEAN
  2648.     if (netUltraDebug) {
  2649.     printf("NetUltraSendDgram: test done.\n");
  2650.     } 
  2651. #endif
  2652.     statePtr->flags &= ~NET_ULTRA_STATE_DSND_TEST;
  2653.     statePtr->flags |= NET_ULTRA_STATE_NORMAL;
  2654.     Timer_SubtractTicks(endTime, startTime, &endTime);
  2655.     Timer_TicksToTime(endTime, timePtr);
  2656. exit:
  2657.     MASTER_UNLOCK(&interPtr->mutex);
  2658.     return status;
  2659. }
  2660.  
  2661. /*
  2662.  *----------------------------------------------------------------------
  2663.  *
  2664.  * DgramSendDone --
  2665.  *
  2666.  *    Called by the interrupt handler when the datagram sent by 
  2667.  *     NetUltraSendDgram is actually sent.
  2668.  *
  2669.  * Results:
  2670.  *    None.
  2671.  *
  2672.  * Side effects:
  2673.  *    The process waiting for the datagram to be sent is notified.
  2674.  *
  2675.  *----------------------------------------------------------------------
  2676.  */
  2677.  
  2678. static void
  2679. DgramSendDone(interPtr, infoPtr)
  2680.     Net_Interface    *interPtr;    /* Interface. */
  2681.     NetUltraXRBInfo    *infoPtr;    /* Info about XRB that completed. */
  2682. {
  2683.     NetUltraXRB            *xrbPtr;
  2684.     NetUltraDatagramRequest    *reqPtr;
  2685.     NetUltraRequestHdr        *hdrPtr;
  2686.  
  2687.     xrbPtr = infoPtr->xrbPtr;
  2688.     reqPtr = &xrbPtr->request.dgram;
  2689.     hdrPtr = &reqPtr->hdr;
  2690.  
  2691.     if (!(hdrPtr->status & NET_ULTRA_STATUS_OK)) {
  2692.     panic("DgramSendDone: dgram send failed 0x%x\n", hdrPtr->status);
  2693.     } else {
  2694. #ifndef CLEAN
  2695.     if (netUltraDebug) {
  2696.         printf("DgramSendDone: datagram sent ok\n");
  2697.     }
  2698. #endif
  2699.     }
  2700.     ((NetUltraState *) interPtr->interfaceData)->numWritePending--;
  2701.     if (((NetUltraState *) interPtr->interfaceData)->numWritePending < 0) {
  2702.     panic("DgramSendDone: number of pending writes < 0.\n");
  2703.     }
  2704.     if (infoPtr->doneData != (ClientData) NIL) {
  2705.     Sync_Broadcast((Sync_Condition *) infoPtr->doneData);
  2706.     }
  2707. #ifndef CLEAN
  2708.     if (netUltraDebug) {
  2709.     printf("DgramSendDone: returning.\n");
  2710.     }
  2711. #endif
  2712.  
  2713. }
  2714.  
  2715.  
  2716. /*
  2717.  *----------------------------------------------------------------------
  2718.  *
  2719.  * NetUltraOutput --
  2720.  *
  2721.  *    Puts the outgoing packet into the queue to the adapter.
  2722.  *    Since the ultranet adapter does not to scatter/gather
  2723.  *    we have to get a free write buffer and copy the data
  2724.  *    into the buffer.
  2725.  *
  2726.  * Results:
  2727.  *    None.
  2728.  *
  2729.  * Side effects:
  2730.  *    The packet is put into the queue and the adapter is notified.
  2731.  *
  2732.  *----------------------------------------------------------------------
  2733.  */
  2734.  
  2735. ReturnStatus
  2736. NetUltraOutput(interPtr, hdrPtr, scatterGatherPtr, scatterGatherLength, rpc,
  2737.         statusPtr)
  2738.     Net_Interface        *interPtr;    /* The interface to use. */
  2739.     Address            hdrPtr;        /* Packet header. */
  2740.     Net_ScatterGather        *scatterGatherPtr; /* Scatter/gather elements.*/
  2741.     int                scatterGatherLength; /* Number of elements in
  2742.                               * scatter/gather list. */
  2743.     Boolean            rpc;        /* Is this an RPC packet? */
  2744.     ReturnStatus        *statusPtr;    /* Place to store status. */
  2745. {
  2746.     NetUltraState        *statePtr;
  2747.     ReturnStatus        status = SUCCESS;
  2748.     Net_UltraHeader        *ultraHdrPtr = (Net_UltraHeader *) hdrPtr;
  2749.  
  2750.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2751.     if ((ultraHdrPtr->cmd != NET_ULTRA_DGRAM_SEND_REQ) && 
  2752.     (ultraHdrPtr->cmd != 0)) {
  2753.     printf("Invalid header to NetUltraOutput.\n");
  2754.     return FAILURE;
  2755.     }
  2756.     /*
  2757.      * If the cmd is 0 then the packet is from the network device.
  2758.      */
  2759.     if (ultraHdrPtr->cmd == 0) {
  2760.     ultraHdrPtr->cmd = NET_ULTRA_DGRAM_SEND_REQ;
  2761.     }
  2762.     MASTER_LOCK(&interPtr->mutex);
  2763.     if (netUltraDebug) {
  2764.     char    address[100];
  2765.     (void) Net_UltraAddrToString(&ultraHdrPtr->remoteAddress.address, 
  2766.             address);
  2767.     printf("NetUltraOutput: sending to %s\n", address);
  2768.     }
  2769.     status = NetUltraSendReq(statePtr, OutputDone, 
  2770.         (ClientData) statusPtr, rpc, scatterGatherLength, 
  2771.         scatterGatherPtr, sizeof(Net_UltraHeader), 
  2772.         (NetUltraRequest *) ultraHdrPtr);
  2773.     if (status != SUCCESS) {
  2774.     printf("NetUltraOutput: packet not sent\n");
  2775.     }
  2776.     MASTER_UNLOCK(&interPtr->mutex);
  2777.     return status;
  2778. }
  2779.  
  2780. /*
  2781.  *----------------------------------------------------------------------
  2782.  *
  2783.  * OutputDone --
  2784.  *
  2785.  *    This routine is called by the interrupt handler when a packet
  2786.  *    sent by NetUltraOutput completes.
  2787.  *
  2788.  * Results:
  2789.  *    None.
  2790.  *
  2791.  * Side effects:
  2792.  *    The write buffer associated with the command is added to
  2793.  *     the list of free write buffers.
  2794.  *
  2795.  *----------------------------------------------------------------------
  2796.  */
  2797.  
  2798. static void
  2799. OutputDone(interPtr, infoPtr)
  2800.     Net_Interface    *interPtr;    /* Interface. */
  2801.     NetUltraXRBInfo    *infoPtr;    /* Info about XRB that completed. */
  2802. {
  2803.     NetUltraRequestHdr        *hdrPtr;
  2804.     NetUltraState        *statePtr;
  2805.     ReturnStatus        *statusPtr;
  2806.     ReturnStatus        status = SUCCESS;
  2807.  
  2808.     hdrPtr = &(infoPtr->xrbPtr->request.dgram.hdr);
  2809.     statusPtr = (ReturnStatus *) infoPtr->doneData;
  2810.  
  2811.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2812.     if (!(hdrPtr->status & NET_ULTRA_STATUS_OK)) {
  2813.     printf("Warning: OutputDone: write failed 0x%x\n", hdrPtr->status);
  2814.     status = FAILURE;
  2815.     } 
  2816. #ifndef CLEAN
  2817.     if (netUltraDebug) {
  2818.     printf("OutputDone: packet sent\n");
  2819.     }
  2820. #endif
  2821.     statePtr->numWritePending--;
  2822.     if (statePtr->numWritePending < 0) {
  2823.     panic("OutputDone: number of pending writes < 0.\n");
  2824.     }
  2825.     /*
  2826.      * Return status to the waiting process.
  2827.      */
  2828.     if (statusPtr != (ReturnStatus *) NIL) {
  2829.     *statusPtr = status;
  2830.     }
  2831.     /*
  2832.      * Wakeup any process waiting for the packet to be sent.
  2833.      */
  2834.     infoPtr->scatterPtr->done = TRUE;
  2835.     if (infoPtr->scatterPtr->mutexPtr != (Sync_Semaphore *) NIL) {
  2836.     NetOutputWakeup(infoPtr->scatterPtr->mutexPtr);
  2837.     }
  2838. }
  2839.  
  2840. /*
  2841.  *----------------------------------------------------------------------
  2842.  *
  2843.  * NetUltraSource --
  2844.  *
  2845.  *    This routine will send a stream of datagrams to the specified host.
  2846.  *
  2847.  * Results:
  2848.  *    None.
  2849.  *
  2850.  * Side effects:
  2851.  *    A write is queued to the adapter.
  2852.  *
  2853.  *----------------------------------------------------------------------
  2854.  */
  2855.  
  2856. static ReturnStatus
  2857. NetUltraSource(interPtr, netAddressPtr, count, bufSize, buffer, timePtr)
  2858.     Net_Interface    *interPtr;        /* Interface to send on. */
  2859.     Net_Address        *netAddressPtr;        /* Host to send to. */
  2860.     int            count;            /* Number of times to send
  2861.                          * datagram. */
  2862.     int            bufSize;        /* Size of data buffer. */
  2863.     Address        buffer;            /* Data to send. */
  2864.     Time        *timePtr;        /* Place to store total 
  2865.                          * time to send datagrams. */
  2866. {
  2867.     NetUltraState        *statePtr;
  2868.     NetUltraRequest        request;
  2869.     NetUltraDatagramRequest    *dgramReqPtr;
  2870.     NetUltraRequestHdr        *hdrPtr;
  2871.     ReturnStatus        status = SUCCESS;
  2872.     List_Links            *itemPtr;
  2873.     Timer_Ticks         startTime;
  2874.     Timer_Ticks         endTime;
  2875.     Timer_Ticks         curTime;
  2876.     NetUltraTraceInfo        *tracePtr;
  2877.     Net_ScatterGather        scatter;
  2878.     char            *ptr;
  2879.  
  2880.     MASTER_LOCK(&interPtr->mutex);
  2881. #ifndef CLEAN
  2882.     if (netUltraDebug) {
  2883.     char    address[100];
  2884.     (void) Net_AddrToString(netAddressPtr, address);
  2885.     printf("NetUltraSendDgram: sending to %s\n", address);
  2886.     }
  2887. #endif
  2888.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2889.     if (!(statePtr->flags & NET_ULTRA_STATE_START)) {
  2890.     printf("NetUltraSendDgram: adapter not started!\n");
  2891.     status = FAILURE;
  2892.     goto exit;
  2893.     }
  2894.     bzero((char *) &request, sizeof(request));
  2895.     dgramReqPtr = &request.dgram;
  2896.     hdrPtr = &dgramReqPtr->hdr;
  2897.     dgramReqPtr->remoteAddress = wildcardAddress;
  2898.     dgramReqPtr->remoteAddress.tsapSize = 2;
  2899.     dgramReqPtr->remoteAddress.tsap[1] = 1;
  2900.     dgramReqPtr->remoteAddress.address = netAddressPtr->address.ultra;
  2901.     ptr = (char *) &dgramReqPtr->remoteAddress.address;
  2902.     ptr[1] = 0x49;
  2903.     ptr[6] = 0xfe;
  2904.     dgramReqPtr->localAddress = wildcardAddress;
  2905.     dgramReqPtr->localAddress.tsapSize = 2;
  2906.     dgramReqPtr->localAddress.tsap[1] = 1;
  2907.     dgramReqPtr->localAddress.address = 
  2908.     interPtr->netAddress[NET_PROTO_RAW].address.ultra;
  2909.     ptr = (char *) &dgramReqPtr->localAddress.address;
  2910.     ptr[1] = 0x49;
  2911.     ptr[6] = 0xfe;
  2912.     hdrPtr->cmd = NET_ULTRA_DGRAM_SEND_REQ;
  2913.     Timer_GetCurrentTicks(&startTime);
  2914.     while(count > 0) {
  2915.     count--;
  2916.     while(List_IsEmpty(statePtr->freeBufferList)) {
  2917.         int        signal;
  2918.         statePtr->bufferAvail.waiting = TRUE;
  2919.         signal = Sync_SlowMasterWait((unsigned int) &statePtr->bufferAvail,
  2920.             &interPtr->mutex, TRUE);
  2921.         if (signal) {
  2922.         status = GEN_ABORTED_BY_SIGNAL;
  2923.         goto exit;
  2924.         }
  2925.     }
  2926.     itemPtr = List_First(statePtr->freeBufferList);
  2927.     if (itemPtr == statePtr->freeBufferList) {
  2928.         panic("NetUltraSendDgram: list screwup\n");
  2929.     }
  2930.     List_Remove(itemPtr);
  2931.     if (buffer != (Address) NIL) {
  2932.         bcopy((char *) buffer, (char *) itemPtr, bufSize);
  2933.     }
  2934.     dsndCount = count;
  2935. #ifndef CLEAN
  2936.     if (netUltraTrace) {
  2937.         NEXT_TRACE(statePtr, &tracePtr);
  2938.         tracePtr->event = DSND_STREAM;
  2939.         Timer_GetCurrentTicks(&curTime);
  2940.         tracePtr->ticks = curTime;
  2941.     }
  2942. #endif
  2943.     scatter.bufAddr = BUFFER_TO_DVMA(itemPtr, statePtr);
  2944.     scatter.length = bufSize;
  2945.     status = NetUltraSendReq(statePtr, SourceDone, 
  2946.             (ClientData) NIL, FALSE, 1, &scatter,
  2947.             sizeof(NetUltraDatagramRequest), &request);
  2948.     }
  2949.     Timer_GetCurrentTicks(&endTime);
  2950.     Timer_SubtractTicks(endTime, startTime, &endTime);
  2951.     Timer_TicksToTime(endTime, timePtr);
  2952. exit:
  2953.     MASTER_UNLOCK(&interPtr->mutex);
  2954.     return status;
  2955. }
  2956.  
  2957. /*
  2958.  *----------------------------------------------------------------------
  2959.  *
  2960.  * SourceDone --
  2961.  *
  2962.  *    This routine is called by the interrupt handler when a packet
  2963.  *    sent by  NetUltraSource completes.
  2964.  *
  2965.  * Results:
  2966.  *    None.
  2967.  *
  2968.  * Side effects:
  2969.  *    The write buffer associated with the command is added to
  2970.  *     the list of free write buffers.
  2971.  *
  2972.  *----------------------------------------------------------------------
  2973.  */
  2974.  
  2975. static void
  2976. SourceDone(interPtr, infoPtr)
  2977.     Net_Interface    *interPtr;    /* Interface. */
  2978.     NetUltraXRBInfo    *infoPtr;    /* Info about XRB that completed. */
  2979. {
  2980.     NetUltraRequestHdr        *hdrPtr;
  2981.     NetUltraState        *statePtr;
  2982.     List_Links            *itemPtr;
  2983.  
  2984.     hdrPtr = &(infoPtr->xrbPtr->request.dgram.hdr);
  2985.  
  2986.     statePtr = (NetUltraState *) interPtr->interfaceData;
  2987.     if (!(hdrPtr->status & NET_ULTRA_STATUS_OK)) {
  2988.     panic("SourceDone: write failed 0x%x (continuable)\n", hdrPtr->status);
  2989.     } else {
  2990. #ifndef CLEAN
  2991.     if (netUltraDebug) {
  2992.         printf("SourceDone: packet sent\n");
  2993.     }
  2994. #endif
  2995.     statePtr->numWritePending--;
  2996.     if (statePtr->numWritePending < 0) {
  2997.         panic("SourceDone: number of pending writes < 0.\n");
  2998.     }
  2999.     /*
  3000.      * Free up the write buffer. 
  3001.      */
  3002.     itemPtr = (List_Links *) VME_TO_BUFFER(hdrPtr->buffer,statePtr);
  3003.     List_Insert(itemPtr, LIST_ATREAR(statePtr->freeBufferList));
  3004.     if (statePtr->bufferAvail.waiting == TRUE) {
  3005.         Sync_Broadcast(&statePtr->bufferAvail);
  3006.     }
  3007.     }
  3008. }
  3009.  
  3010. /*
  3011.  *----------------------------------------------------------------------
  3012.  *
  3013.  * NetUltraGetStats --
  3014.  *
  3015.  *    Return the statistics for the interface.
  3016.  *
  3017.  * Results:
  3018.  *    A pointer to the statistics structure.
  3019.  *
  3020.  * Side effects:
  3021.  *    None.
  3022.  *
  3023.  *----------------------------------------------------------------------
  3024.  */
  3025.  
  3026. ReturnStatus
  3027. NetUltraGetStats(interPtr, statPtr)
  3028.     Net_Interface    *interPtr;        /* Current interface. */
  3029.     Net_Stats        *statPtr;        /* Statistics to return. */
  3030. {
  3031.     NetUltraState    *statePtr;
  3032.  
  3033.     statePtr = (NetUltraState *) interPtr->interfaceData;
  3034.     MASTER_LOCK(&interPtr->mutex);
  3035.     statPtr->ultra = statePtr->stats;
  3036.     MASTER_UNLOCK(&interPtr->mutex);
  3037.     return SUCCESS;
  3038. }
  3039.  
  3040.